arpakitlib 1.8.15__py3-none-any.whl → 1.8.16__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/middleware/common.py

@@ -0,0 +1,13 @@
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+
+
+class MiddlewareDataTgBot(BaseModel):
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+
+    user_dbm: UserDBM | None = None
+    user_dbm_just_created: bool | None = None
+    additional_data: dict[str, Any] = {}

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/middleware/init_user.py

@@ -0,0 +1,84 @@
+import logging
+from typing import Any, Awaitable, Callable, Dict
+
+import aiogram
+from aiogram import BaseMiddleware
+from aiogram.types import TelegramObject
+
+from project.core.settings import get_cached_settings
+from project.core.util import now_local_dt
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+_logger = logging.getLogger(__name__)
+
+
+class InitUserTgBotMiddleware(BaseMiddleware):
+
+    async def __call__(
+            self,
+            handler: Callable[[TelegramObject, Dict[str, Any]], Awaitable[Any]],
+            event: TelegramObject,
+            data: Dict[str, Any],
+    ) -> Any:
+        _logger.info("start")
+
+        if "middleware_data_tg_bot" in data:
+            middleware_data_tg_bot = data["middleware_data_tg_bot"]
+        else:
+            middleware_data_tg_bot = MiddlewareDataTgBot()
+            data["middleware_data_tg_bot"] = middleware_data_tg_bot
+
+        tg_user: aiogram.types.User | None = None
+        if event.event_type == "message":
+            tg_user = event.message.from_user
+        elif event.event_type == "callback_query":
+            tg_user = event.callback_query.from_user
+        elif event.event_type == "inline_query":
+            tg_user = event.inline_query.from_user
+
+        if tg_user is not None:
+            middleware_data_tg_bot.additional_data["tg_user_was_found"] = tg_user
+            middleware_data_tg_bot.additional_data["found_tg_user_id"] = tg_user.id
+
+        now_local_dt_ = now_local_dt()
+
+        if tg_user is not None and get_cached_sqlalchemy_db() is not None:
+            with get_cached_sqlalchemy_db().new_session() as session:
+                middleware_data_tg_bot.user_dbm = (
+                    session.query(UserDBM).filter(UserDBM.tg_id == tg_user.id).one_or_none()
+                )
+                if middleware_data_tg_bot.user_dbm is None:
+                    roles = [UserDBM.Roles.client]
+                    if tg_user.id in get_cached_settings().tg_bot_admin_tg_ids:
+                        roles.append(UserDBM.Roles.admin)
+                    middleware_data_tg_bot.user_dbm = UserDBM(
+                        creation_dt=now_local_dt_,
+                        roles=roles,
+                        tg_id=tg_user.id,
+                        tg_data=tg_user.model_dump(mode="json"),
+                        tg_bot_last_action_dt=now_local_dt_
+                    )
+                    session.add(middleware_data_tg_bot.user_dbm)
+                    session.commit()
+                    session.refresh(middleware_data_tg_bot.user_dbm)
+                    middleware_data_tg_bot.user_dbm_just_created = True
+                    _logger.info(f"user_dbm was added, {middleware_data_tg_bot.user_dbm}")
+                else:
+                    middleware_data_tg_bot.user_dbm.tg_data = tg_user.model_dump(mode="json")
+                    middleware_data_tg_bot.user_dbm.tg_bot_last_action_dt = now_local_dt_
+                    if (
+                            tg_user.id in get_cached_settings().tg_bot_admin_tg_ids
+                            and UserDBM.Roles.admin not in middleware_data_tg_bot.user_dbm.roles
+                    ):
+                        middleware_data_tg_bot.user_dbm.roles = (
+                                middleware_data_tg_bot.user_dbm.roles + [UserDBM.Roles.admin]
+                        )
+                    session.commit()
+                    session.refresh(middleware_data_tg_bot.user_dbm)
+                    middleware_data_tg_bot.user_dbm_just_created = False
+
+        _logger.info("finish")
+
+        return await handler(event, data)

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/tg_bot/middleware/middleware.py

@@ -5,8 +5,7 @@ from project.tg_bot.middleware.init_user import InitUserTgBotMiddleware
 
 def register_middlewares_to_tg_bot(
         *,
-        tg_bot_dispatcher: aiogram.Dispatcher,
-        **kwargs
+        tg_bot_dispatcher: aiogram.Dispatcher
 ) -> aiogram.Dispatcher:
     tg_bot_dispatcher.update.outer_middleware.register(InitUserTgBotMiddleware())
     return tg_bot_dispatcher

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/admin/arpakitlib_project_template_info.py

@@ -0,0 +1,25 @@
+import aiogram.filters
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    aiogram.filters.Command(AdminTgBotCommands.arpakitlib_project_template_info)
+)
+@as_tg_command()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(
+        text=get_cached_admin_tg_bot_blank().arpakit_project_template_info(
+            arpakitlib_project_template_info=get_arpakitlib_project_template_info()
+        )
+    )

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/admin/main_router.py

@@ -0,0 +1,15 @@
+from aiogram import Router
+
+from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
+from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
+from project.tg_bot.router.admin import reinit_sqlalchemy_db, arpakitlib_project_template_info, raise_fake_error, me
+
+main_admin_tg_bot_router = Router()
+for observer in main_admin_tg_bot_router.observers.values():
+    observer.filter(UserRolesHasAdminTgBotFilter())
+    observer.filter(IsPrivateChatTgBotFilter())
+
+main_admin_tg_bot_router.include_router(reinit_sqlalchemy_db.tg_bot_router)
+main_admin_tg_bot_router.include_router(arpakitlib_project_template_info.tg_bot_router)
+main_admin_tg_bot_router.include_router(raise_fake_error.tg_bot_router)
+main_admin_tg_bot_router.include_router(me.tg_bot_router)

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/admin/me.py

@@ -0,0 +1,20 @@
+import aiogram.filters
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    aiogram.filters.Command(AdminTgBotCommands.me)
+)
+@as_tg_command()
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_admin_tg_bot_blank().user_dbm(user_dbm=middleware_data_tg_bot.user_dbm))

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/admin/raise_fake_error.py

@@ -0,0 +1,20 @@
+import aiogram.filters
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.core.settings import get_cached_settings
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    aiogram.filters.Command(AdminTgBotCommands.raise_fake_err)
+)
+@as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    raise Exception("fake error")

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/admin/reinit_sqlalchemy_db.py

@@ -0,0 +1,27 @@
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command
+
+from arpakitlib.ar_aiogram_util import as_tg_command
+from project.core.settings import get_cached_settings
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.tg_bot.blank.admin import get_cached_admin_tg_bot_blank
+from project.tg_bot.const import AdminTgBotCommands
+from project.tg_bot.filter_.not_prod_mode_filter import NotProdModeTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.message(
+    Command(AdminTgBotCommands.reinit_sqlalchemy_db),
+    NotProdModeTgBotFilter()
+)
+@as_tg_command(passwd_validator=get_cached_settings().tg_bot_command_passwd)
+async def handler(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    get_cached_sqlalchemy_db().reinit()
+    await m.answer(text=get_cached_admin_tg_bot_blank().done())

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/client/healthcheck.py

@@ -0,0 +1,16 @@
+import aiogram.filters
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(aiogram.filters.Command(ClientTgBotCommands.healthcheck))
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().healthcheck())

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/client/hello_world.py

@@ -0,0 +1,44 @@
+import aiogram.filters
+from aiogram.filters import or_f
+
+from arpakitlib.ar_str_util import remove_html
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.callback.client import HelloWorldClientCD
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.kb.inline_.client.hello_world import hello_world_client_inline_kb_tg_bot
+from project.tg_bot.kb.static_.client.hello_world import hello_world_client_static_kb_tg_bot
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(
+    or_f(
+        aiogram.filters.Command(ClientTgBotCommands.hello_world),
+        MessageTextTgBotFilter(get_cached_client_tg_bot_blank().but_hello_world())
+    )
+)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(
+        text=get_cached_client_tg_bot_blank().hello_world(),
+        reply_markup=hello_world_client_inline_kb_tg_bot()
+    )
+    await m.answer(
+        text=get_cached_client_tg_bot_blank().hello_world(),
+        reply_markup=hello_world_client_static_kb_tg_bot()
+    )
+
+
+@tg_bot_router.callback_query(HelloWorldClientCD.filter())
+async def _(
+        cq: aiogram.types.CallbackQuery,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await cq.message.delete_reply_markup()
+    await cq.message.answer(text=remove_html(get_cached_client_tg_bot_blank().hello_world()))

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/client/main_router.py

@@ -0,0 +1,14 @@
+from aiogram import Router
+
+from project.tg_bot.filter_.user_roles_has_client import UserRolesHasClientTgBotFilter
+from project.tg_bot.router.client import start, healthcheck, hello_world
+
+main_client_tg_bot_router = Router()
+for observer in main_client_tg_bot_router.observers.values():
+    observer.filter(UserRolesHasClientTgBotFilter())
+
+main_client_tg_bot_router.include_router(router=start.tg_bot_router)
+
+main_client_tg_bot_router.include_router(router=healthcheck.tg_bot_router)
+
+main_client_tg_bot_router.include_router(router=hello_world.tg_bot_router)

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/client/start.py

@@ -0,0 +1,33 @@
+import logging
+
+import aiogram
+from aiogram import Router
+from aiogram.filters import Command, or_f
+
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands
+from project.tg_bot.filter_.message_text import MessageTextTgBotFilter
+from project.tg_bot.middleware.common import MiddlewareDataTgBot
+
+tg_bot_router = Router()
+_logger = logging.getLogger(__name__)
+
+
+@tg_bot_router.message(
+    or_f(
+        Command(ClientTgBotCommands.start),
+        MessageTextTgBotFilter([
+            "начать",
+            "старт",
+            "привет",
+            "запуск",
+            "start",
+        ], ignore_case=True)
+    )
+)
+async def _(
+        m: aiogram.types.Message,
+        middleware_data_tg_bot: MiddlewareDataTgBot,
+        **kwargs
+):
+    await m.answer(text=get_cached_client_tg_bot_blank().welcome())

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/main_router.py

@@ -0,0 +1,13 @@
+from aiogram import Router
+
+from project.tg_bot import error_handler
+from project.tg_bot.router.admin.main_router import main_admin_tg_bot_router
+from project.tg_bot.router.client.main_router import main_client_tg_bot_router
+
+main_tg_bot_router = Router()
+
+main_tg_bot_router.include_router(router=error_handler.tg_bot_router)
+
+main_tg_bot_router.include_router(router=main_admin_tg_bot_router)
+
+main_tg_bot_router.include_router(router=main_client_tg_bot_router)

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/tg_bot/start_tg_bot.py

@@ -6,14 +6,14 @@ from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_applicati
 
 from project.core.settings import get_cached_settings
 from project.core.util import setup_logging
-from project.tg_bot.tg_bot import create_tg_bot
+from project.tg_bot.tg_bot import get_cached_tg_bot
 from project.tg_bot.tg_bot_dispatcher import create_tg_bot_dispatcher
 
 
 def start_tg_bot():
     setup_logging()
 
-    tg_bot = create_tg_bot()
+    tg_bot = get_cached_tg_bot()
 
     tg_bot_dispatcher = create_tg_bot_dispatcher()
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/tg_bot/tg_bot.py

@@ -1,3 +1,5 @@
+from functools import lru_cache
+
 import aiogram
 from aiogram.client.default import DefaultBotProperties
 from aiogram.client.session.aiohttp import AiohttpSession
@@ -22,3 +24,8 @@ def create_tg_bot() -> aiogram.Bot:
     )
 
     return tg_bot
+
+
+@lru_cache()
+def get_cached_tg_bot() -> aiogram.Bot:
+    return create_tg_bot()

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/util/set_tg_bot_commands.py

@@ -0,0 +1,76 @@
+import asyncio
+import logging
+
+from aiogram.types import BotCommand, BotCommandScopeChat
+
+from arpakitlib.ar_str_util import return_str_if_none
+from project.core.util import setup_logging
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
+from project.tg_bot.blank.client import get_cached_client_tg_bot_blank
+from project.tg_bot.const import ClientTgBotCommands, AdminTgBotCommands
+from project.tg_bot.tg_bot import get_cached_tg_bot
+
+_logger = logging.getLogger(__name__)
+
+
+def get_client_tg_bot_commands_to_set() -> list[BotCommand]:
+    res = [
+        BotCommand(
+            command=ClientTgBotCommands.start,
+            description=return_str_if_none(
+                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.start),
+                ClientTgBotCommands.start
+            )
+        ),
+        BotCommand(
+            command=ClientTgBotCommands.about,
+            description=return_str_if_none(
+                get_cached_client_tg_bot_blank().command_to_desc().get(ClientTgBotCommands.about),
+                ClientTgBotCommands.about
+            )
+        )
+    ]
+    return res
+
+
+def get_admin_tg_bot_commands_to_set() -> list[BotCommand]:
+    res = []
+    for command in AdminTgBotCommands.values_list():
+        res.append(BotCommand(
+            command=command,
+            description=command
+        ))
+    return res
+
+
+async def set_client_tg_bot_commands():
+    _logger.info(f"start")
+    await get_cached_tg_bot().set_my_commands(commands=get_client_tg_bot_commands_to_set())
+    _logger.info("finish")
+
+
+async def set_admin_tg_bot_commands():
+    _logger.info(f"start")
+
+    with get_cached_sqlalchemy_db().new_session() as session:
+        user_dbms: list[UserDBM] = session.query(UserDBM).filter(UserDBM.roles.any(UserDBM.Roles.admin)).all()
+
+    for user_dbm in user_dbms:
+        await get_cached_tg_bot().set_my_commands(
+            commands=get_client_tg_bot_commands_to_set() + get_admin_tg_bot_commands_to_set(),
+            scope=BotCommandScopeChat(chat_id=user_dbm.tg_id)
+        )
+
+    _logger.info("finish")
+
+
+async def __async_example():
+    setup_logging()
+    await set_client_tg_bot_commands()
+    await set_admin_tg_bot_commands()
+    await get_cached_tg_bot().session.close()
+
+
+if __name__ == '__main__':
+    asyncio.run(__async_example())

arpakitlib/ar_aiogram_util.py

@@ -45,7 +45,6 @@ def as_tg_command(
         *params: TgCommandFlagParam | TgCommandKeyValueParam,
         desc: str | None = None,
         passwd_validator: Callable | str | None = None,
-        passwd: str | None = None,
         remove_message_after_correct_passwd: bool = True
 ):
     _PASSWD_KEY = "passwd"
@@ -53,8 +52,6 @@ def as_tg_command(
 
     params = list(params)
 
-    if passwd_validator is None and passwd is not None:
-        passwd_validator = passwd
     if passwd_validator is not None:
         raise_for_types(passwd_validator, [Callable, str])
         params.append(TgCommandKeyValueParam(key=_PASSWD_KEY, required=True, index=None, need_type=NeedTypes.str_))

arpakitlib/ar_arpakit_schedule_uust_api_client_util.py

@@ -14,7 +14,6 @@ from pydantic import ConfigDict, BaseModel
 
 from arpakitlib.ar_enumeration_util import Enumeration
 from arpakitlib.ar_http_request_util import async_make_http_request
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -415,70 +414,7 @@ def __example():
 
 
 async def __async_example():
-    client = ARPAKITScheduleUUSTAPIClient(api_key="viewer", use_cache=True)
-
-    print(f"check_auth")
-    print(safely_transfer_obj_to_json_str(await client.check_auth()))
-
-    print(f"get_weather_in_ufa")
-    print(safely_transfer_obj_to_json_str((await client.get_weather_in_ufa()).model_dump()))
-
-    print(f"get_now_datetime_in_ufa")
-    print(safely_transfer_obj_to_json_str((await client.get_now_datetime_in_ufa()).model_dump()))
-
-    # print(f"get_current_week")
-    # print(safely_transfer_obj_to_json_str((await client.get_current_week()).model_dump()))
-    #
-    # print(f"get_current_semester")
-    # print(safely_transfer_obj_to_json_str((await client.get_current_semester()).model_dump()))
-    #
-    # # Group
-    # print(f"get_groups")
-    # print(safely_transfer_obj_to_json_str((await client.get_groups())))
-    #
-    # print(f"get_group")
-    # if await client.get_group(filter_id=25285, filter_uust_api_id=6674):
-    #     print(safely_transfer_obj_to_json_str(
-    #         (await client.get_group(filter_id=25285, filter_uust_api_id=6674)).model_dump()))
-    # else:
-    #     print("Group is none")
-    #
-    # print(f"find_groups")
-    # print(safely_transfer_obj_to_json_str((await client.find_groups(q="ПИ-427Б"))))
-    #
-    # # Teacher
-    # print(f"get_teachers")
-    # print(safely_transfer_obj_to_json_str((await client.get_teachers())))
-    #
-    # print(f"get_teacher")
-    # if await client.get_teacher(filter_id=16975, filter_uust_api_id=112978):
-    #     print(safely_transfer_obj_to_json_str(
-    #         (await client.get_teacher(filter_id=16975, filter_uust_api_id=112978)).model_dump()))
-    # else:
-    #     print("Teacher is none")
-    #
-    # print(f"find_teachers")
-    # print(safely_transfer_obj_to_json_str((await client.find_teachers(q="Казанцев"))))
-    #
-    # # Group Lesson
-    # print(f"get_group_lessons")
-    # if await client.get_group_lessons(filter_group_id=25285, filter_group_uust_api_id=6674):
-    #     print(safely_transfer_obj_to_json_str((await client.get_group_lessons(filter_group_id=25285,
-    #                                                                           filter_group_uust_api_id=6674))))
-    # else:
-    #     print("Group lessons is none")
-    #
-    # # Teacher Lesson
-    # print(f"get_teacher_lessons")
-    # if await client.get_teacher_lessons(filter_teacher_id=16975, filter_teacher_uust_api_id=112978):
-    #     print(safely_transfer_obj_to_json_str((await client.get_teacher_lessons(filter_teacher_id=16975,
-    #                                                                             filter_teacher_uust_api_id=112978))))
-    # else:
-    #     print("Teacher lessons is none")
-    #
-    # # Find Any
-    # print(f"find_any")
-    # print(safely_transfer_obj_to_json_str((await client.find_any(q="ПИ"))))
+    pass
 
 
 if __name__ == '__main__':

arpakitlib/ar_json_util.py

@@ -3,33 +3,64 @@
 import json
 from typing import Any
 
+import orjson
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def safely_transfer_str_to_json_obj(data: str) -> dict[Any, Any] | list[Any] | None:
-    if not isinstance(data, str):
-        raise ValueError("not isinstance(data, str)")
-    return json.loads(data)
+def transfer_json_str_to_data(
+        json_str: str, fast: bool = False
+) -> dict[Any, Any] | list[Any] | None:
+    if not isinstance(json_str, str):
+        raise ValueError("not isinstance(json_str, str)")
+    if fast:
+        return orjson.loads(json_str)
+    else:
+        return json.loads(json_str)
 
 
-def safely_transfer_obj_to_json_str(data: dict[Any, Any] | list[Any] | None) -> str:
+def transfer_data_to_json_str(
+        data: dict[Any, Any] | list[Any] | None, beautify: bool = True, fast: bool = False
+) -> str:
     if not isinstance(data, dict) and not isinstance(data, list) and data is not None:
         raise ValueError("not isinstance(data, dict) and not isinstance(data, list) and data is not None")
-    return json.dumps(data, ensure_ascii=False, indent=2, default=str)
+    if fast:
+        return orjson.dumps(data).decode()
+    else:
+        if beautify:
+            return json.dumps(data, ensure_ascii=False, indent=2, default=str)
+        else:
+            return json.dumps(data, ensure_ascii=False, default=str)
 
 
-def safely_transfer_obj_to_json_str_to_json_obj(
-        data: dict[Any, Any] | list[Any] | None
+def transfer_data_to_json_str_to_data(
+        data: dict[Any, Any] | list[Any] | None, fast: bool = False
 ) -> dict[Any, Any] | list[Any] | None:
-    return safely_transfer_str_to_json_obj(safely_transfer_obj_to_json_str(data))
+    return transfer_json_str_to_data(transfer_data_to_json_str(data=data, fast=fast), fast=fast)
 
 
-def safely_transfer_str_to_json_obj_to_json_str(data: str) -> str:
-    return safely_transfer_obj_to_json_str(safely_transfer_str_to_json_obj(data))
+def transfer_json_str_to_data_to_json_str(
+        json_str: str, beautify: bool = True, fast: bool = False
+) -> str:
+    return transfer_data_to_json_str(
+        transfer_json_str_to_data(json_str=json_str, fast=fast), beautify=beautify, fast=fast
+    )
 
 
 def __example():
-    pass
+    res = {str(k): v * "123" for k, v in enumerate(list(range(90000)))}
+
+    print("---")
+
+    now = now_utc_dt()
+    transfer_data_to_json_str(data=res, beautify=True, fast=False)
+    print(now_utc_dt() - now)
+
+    now = now_utc_dt()
+    transfer_data_to_json_str(data=res, fast=True)
+    print(now_utc_dt() - now)
 
 
 if __name__ == '__main__':

arpakitlib/ar_sqlalchemy_util.py

@@ -12,7 +12,7 @@ from sqlalchemy.orm import sessionmaker, DeclarativeBase
 from sqlalchemy.orm.session import Session
 
 from arpakitlib.ar_datetime_util import now_utc_dt
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_json_util import transfer_data_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -105,7 +105,7 @@ class BaseDBM(DeclarativeBase):
         return self.simple_dict(include_sd_properties=True)
 
     def simple_dict_json(self, *, include_sd_properties: bool = True) -> str:
-        return safely_transfer_obj_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
+        return transfer_data_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
 
 
 class SQLAlchemyDb: