arpakitlib 1.7.257__py3-none-any.whl → 1.8.1__py3-none-any.whl

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v_1}/tg_bot/filter/prod_mode.py

@@ -1,6 +1,6 @@
 from aiogram.filters import Filter
 
-from src.core.settings import get_cached_settings
+from core.settings import get_cached_settings
 
 
 class ProdModeFilter(Filter):

arpakitlib/_arpakit_project_template_v_1/tg_bot/middleware/init_user.py

@@ -0,0 +1,24 @@
+import logging
+from typing import Any, Awaitable, Callable, Dict
+
+from aiogram import BaseMiddleware
+from aiogram.types import TelegramObject
+
+from tg_bot.transmitted_tg_data import TransmittedTgBotData
+
+_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")
+        transmitted_tg_bot_data: TransmittedTgBotData = data["transmitted_tg_bot_data"]
+        # ...
+        _logger.info("finish")
+        return await handler(event, data)

arpakitlib/_arpakit_project_template_v_1/tg_bot/middleware/middleware.py

@@ -0,0 +1,12 @@
+import aiogram
+
+from tg_bot.middleware.init_user import InitUserTgBotMiddleware
+
+
+def register_tg_bot_middleware(
+        *,
+        tg_bot_dp: aiogram.Dispatcher,
+        **kwargs
+) -> aiogram.Dispatcher:
+    tg_bot_dp.update.outer_middleware.register(InitUserTgBotMiddleware())
+    return tg_bot_dp

arpakitlib/_arpakit_project_template_v_1/tg_bot/router/arpakitlib_.py

@@ -0,0 +1,10 @@
+import aiogram.filters
+
+from tg_bot.const import TgBotCommands
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(aiogram.filters.Command(TgBotCommands.arpakitlib))
+async def _(m: aiogram.types.Message, **kwargs):
+    await m.answer(text="arpakitlib")

arpakitlib/_arpakit_project_template_v_1/tg_bot/router/error.py

@@ -0,0 +1,15 @@
+import aiogram
+from aiogram import Router
+
+from tg_bot.transmitted_tg_data import TransmittedTgBotData
+
+tg_bot_router = Router()
+
+
+@tg_bot_router.error()
+async def _(
+        event: aiogram.types.ErrorEvent,
+        transmitted_tg_bot_data: TransmittedTgBotData,
+        **kwargs
+):
+    pass

arpakitlib/_arpakit_project_template_v_1/tg_bot/router/healthcheck.py

@@ -0,0 +1,10 @@
+import aiogram.filters
+
+from tg_bot.const import TgBotCommands
+
+tg_bot_router = aiogram.Router()
+
+
+@tg_bot_router.message(aiogram.filters.Command(TgBotCommands.healthcheck))
+async def _(m: aiogram.types.Message, **kwargs):
+    await m.answer(text="healthcheck")

arpakitlib/_arpakit_project_template_v_1/tg_bot/router/main_router.py

@@ -0,0 +1,14 @@
+from aiogram import Router
+
+from tg_bot.router import error
+from tg_bot.router import healthcheck
+
+main_tg_bot_router = Router()
+
+# Healthcheck
+
+main_tg_bot_router.include_router(router=healthcheck.tg_bot_router)
+
+# Error
+
+main_tg_bot_router.include_router(router=error.tg_bot_router)

arpakitlib/_arpakit_project_template_v_1/tg_bot/start_tg_bot.py

@@ -0,0 +1,34 @@
+from arpakitlib.ar_aiogram_util import start_aiogram_tg_bot_with_webhook
+from core.util import setup_logging
+from tg_bot.event import add_events_to_tg_bot_dispatcher
+from tg_bot.tg_bot import create_tg_bot
+from tg_bot.tg_bot_dispatcher import create_tg_bot_dispatcher
+from tg_bot.transmitted_tg_data import get_cached_transmitted_tg_bot_data
+
+
+def start_tg_bot():
+    setup_logging()
+
+    transmitted_tg_bot_data = get_cached_transmitted_tg_bot_data()
+
+    tg_bot = create_tg_bot()
+
+    tg_bot_dispatcher = create_tg_bot_dispatcher()
+
+    add_events_to_tg_bot_dispatcher(tg_bot_dispatcher=tg_bot_dispatcher)
+
+    if transmitted_tg_bot_data.settings.tg_bot_webhook_enabled:
+        tg_bot_dispatcher.start_polling(tg_bot)
+    else:
+        start_aiogram_tg_bot_with_webhook(
+            dispatcher=tg_bot_dispatcher,
+            bot=tg_bot,
+            webhook_secret=transmitted_tg_bot_data.settings.tg_bot_webhook_secret,
+            webhook_path=transmitted_tg_bot_data.settings.tg_bot_webhook_path,
+            webhook_server_hostname=transmitted_tg_bot_data.settings.tg_bot_webhook_server_hostname,
+            webhook_server_port=transmitted_tg_bot_data.settings.tg_bot_webhook_server_port
+        )
+
+
+if __name__ == '__main__':
+    start_tg_bot()

arpakitlib/_arpakit_project_template_v_1/tg_bot/tg_bot.py

@@ -0,0 +1,24 @@
+import aiogram
+from aiogram.client.default import DefaultBotProperties
+from aiogram.client.session.aiohttp import AiohttpSession
+from aiogram.enums import ParseMode
+
+from core.settings import get_cached_settings
+
+
+def create_tg_bot() -> aiogram.Bot:
+    session: AiohttpSession | None = None
+    if get_cached_settings().tg_bot_proxy_url is not None:
+        session = AiohttpSession(proxy=get_cached_settings().tg_bot_proxy_url)
+
+    tg_bot = aiogram.Bot(
+        token=get_cached_settings().tg_bot_token,
+        session=session,
+        default=DefaultBotProperties(
+            parse_mode=ParseMode.HTML,
+            disable_notification=False,
+            link_preview_is_disabled=True
+        )
+    )
+
+    return tg_bot

arpakitlib/_arpakit_project_template_v_1/tg_bot/tg_bot_dispatcher.py

@@ -0,0 +1,19 @@
+import aiogram
+from aiogram.fsm.storage.memory import MemoryStorage
+
+from tg_bot.event import add_events_to_tg_bot_dispatcher
+from tg_bot.router.main_router import main_tg_bot_router
+from tg_bot.transmitted_tg_data import get_cached_transmitted_tg_bot_data
+
+
+def create_tg_bot_dispatcher() -> aiogram.Dispatcher:
+    tg_bot_dispatcher = aiogram.Dispatcher(
+        storage=MemoryStorage(),
+        transmitted_tg_bot_data=get_cached_transmitted_tg_bot_data()
+    )
+
+    add_events_to_tg_bot_dispatcher(tg_bot_dispatcher=tg_bot_dispatcher)
+
+    tg_bot_dispatcher.include_router(router=main_tg_bot_router)
+
+    return tg_bot_dispatcher

arpakitlib/_arpakit_project_template_v_1/tg_bot/transmitted_tg_data.py

@@ -0,0 +1,58 @@
+from functools import lru_cache
+
+from pydantic import BaseModel
+
+from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
+from arpakitlib.ar_json_db_util import BaseJSONDb
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDb
+from core.cache_file_storage_in_dir import get_cached_cache_file_storage_in_dir
+from core.dump_file_storage_in_dir import get_cached_dump_file_storage_in_dir
+from core.media_file_storage_in_dir import get_cached_media_file_storage_in_dir
+from core.settings import Settings, get_cached_settings
+from json_db.json_db import get_cached_json_db
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
+
+
+class TransmittedTgBotData(BaseModel):
+    settings: Settings | None = None
+    sqlalchemy_db: SQLAlchemyDb | None = None
+    json_db: BaseJSONDb | None = None
+    media_file_storage_in_dir: FileStorageInDir | None = None
+    cache_file_storage_in_dir: FileStorageInDir | None = None
+    dump_file_storage_in_dir: FileStorageInDir | None = None
+
+
+def create_transmitted_tg_bot_data() -> TransmittedTgBotData:
+    settings = get_cached_settings()
+
+    sqlalchemy_db = get_cached_sqlalchemy_db() if settings.sqlalchemy_sync_db_url is not None else None
+
+    json_db = get_cached_json_db() if settings.json_db_dirpath is not None else None
+
+    media_file_storage_in_dir = (
+        get_cached_media_file_storage_in_dir() if settings.media_dirpath is not None else None
+    )
+
+    cache_file_storage_in_dir = (
+        get_cached_cache_file_storage_in_dir() if settings.cache_dirpath is not None else None
+    )
+
+    dump_file_storage_in_dir = (
+        get_cached_dump_file_storage_in_dir() if settings.dump_dirpath is not None else None
+    )
+
+    transmitted_api_data = TransmittedTgBotData(
+        settings=settings,
+        sqlalchemy_db=sqlalchemy_db,
+        json_db=json_db,
+        media_file_storage_in_dir=media_file_storage_in_dir,
+        cache_file_storage_in_dir=cache_file_storage_in_dir,
+        dump_file_storage_in_dir=dump_file_storage_in_dir,
+    )
+
+    return transmitted_api_data
+
+
+@lru_cache()
+def get_cached_transmitted_tg_bot_data() -> TransmittedTgBotData:
+    return create_transmitted_tg_bot_data()

arpakitlib/_arpakit_project_template_v_1/util/read_arpakitlib_project_template_file.py

@@ -0,0 +1,17 @@
+import json
+from typing import Any
+
+from core.const import ProjectPaths
+
+
+def read_arpakitlib_project_template_file() -> dict[str, Any]:
+    with open(ProjectPaths.arpakit_lib_project_template_filepath, mode="r", encoding="utf-8") as fr:
+        return json.load(fp=fr)
+
+
+def __example():
+    print(read_arpakitlib_project_template_file())
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_aiogram_util.py

@@ -4,21 +4,20 @@ import asyncio
 import logging
 from typing import Optional, Any, Union, Callable, Iterable
 
-from aiogram import types, Bot
-from aiogram.client.default import DefaultBotProperties
-from aiogram.client.session.aiohttp import AiohttpSession
-from aiogram.enums import ChatType, ParseMode
+import aiogram
+import aiohttp
+import aiohttp.web
+from aiogram import types
+from aiogram.enums import ChatType
 from aiogram.exceptions import AiogramError
 from aiogram.filters import CommandObject, Filter
 from aiogram.filters.callback_data import CallbackData
-from pydantic import BaseModel, ConfigDict
+from aiogram.webhook.aiohttp_server import SimpleRequestHandler, setup_application
+from aiohttp import web
+from pydantic import BaseModel
 
-from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
-from arpakitlib.ar_json_db_util import BaseJSONDb
 from arpakitlib.ar_need_type_util import parse_need_type, NeedTypes
 from arpakitlib.ar_parse_command import BadCommandFormat, parse_command
-from arpakitlib.ar_settings_util import BaseSettings2
-from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDb
 from arpakitlib.ar_type_util import raise_for_types, raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -141,7 +140,7 @@ class TgCommandKeyValueParam(BaseTgCommandParam):
 def as_tg_command(
         *params: TgCommandFlagParam | TgCommandKeyValueParam,
         desc: str | None = None,
-        check_passwd: Callable | str | None = None,
+        passwd_validator: Callable | str | None = None,
         passwd: str | None = None,
         remove_message_after_correct_passwd: bool = True
 ):
@@ -150,10 +149,10 @@ def as_tg_command(
 
     params = list(params)
 
-    if check_passwd is None and passwd is not None:
-        check_passwd = passwd
-    if check_passwd is not None:
-        raise_for_types(check_passwd, [Callable, str])
+    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_))
 
     params.append(TgCommandFlagParam(key=_HELP_FLAG))
@@ -196,7 +195,7 @@ def as_tg_command(
                         text += "\n\n" + desc
                     text += "\n\n"
 
-                    if check_passwd is not None:
+                    if passwd_validator is not None:
                         text += "Passwd is required\n\n"
 
                     text += "<b>Keys:</b>\n"
@@ -236,16 +235,16 @@ def as_tg_command(
                     await message.answer(text=text.strip())
                     return
 
-                if check_passwd is not None:
+                if passwd_validator is not None:
                     passwd_ = parsed_command.get_value_by_key(_PASSWD_KEY)
                     if not passwd_:
                         is_passwd_correct = False
-                    elif isinstance(check_passwd, Callable):
-                        is_passwd_correct = check_passwd(
+                    elif isinstance(passwd_validator, Callable):
+                        is_passwd_correct = passwd_validator(
                             passwd=passwd_, message=message, parsed_command=parsed_command
                         )
-                    elif isinstance(check_passwd, str):
-                        is_passwd_correct = (check_passwd == passwd_)
+                    elif isinstance(passwd_validator, str):
+                        is_passwd_correct = (passwd_validator == passwd_)
                     else:
                         raise TypeError("check_passwd is not not Callable and not str")
                     if not is_passwd_correct:
@@ -315,38 +314,28 @@ def as_tg_command(
     return decorator
 
 
-class BaseTransmittedTgBotData(BaseModel):
-    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
-
-
-class SimpleTransmittedTgBotData(BaseTransmittedTgBotData):
-    settings: BaseSettings2 | None = None
-
-
-class AdvancedTransmittedTgBotData(SimpleTransmittedTgBotData):
-    sqlalchemy_db: SQLAlchemyDb | None = None
-    json_db: BaseJSONDb | None = None
-    media_file_storage_in_dir: FileStorageInDir | None = None
-    cache_file_storage_in_dir: FileStorageInDir | None = None
-    dump_file_storage_in_dir: FileStorageInDir | None = None
-
-
-def create_aiogram_tg_bot(*, token: str, proxy_url_: str | None = None, **kwargs) -> Bot:
-    kwargs["token"] = token
-
-    if proxy_url_ is not None:
-        kwargs["session"] = AiohttpSession(proxy=proxy_url_)
-
-    if kwargs.get("default") is None:
-        kwargs["default"] = DefaultBotProperties(
-            parse_mode=ParseMode.HTML,
-            disable_notification=False,
-            link_preview_is_disabled=True
-        )
-
-    tg_bot = Bot(**kwargs)
-
-    return tg_bot
+def start_aiogram_tg_bot_with_webhook(
+        *,
+        dispatcher: aiogram.Dispatcher,
+        bot: aiogram.Bot,
+        webhook_secret: str = "123",
+        webhook_path: str = "/tg_bot_webhook",
+        webhook_server_hostname: str = "127.0.0.1",
+        webhook_server_port: int = 8080
+):
+    app = aiohttp.web.Application()
+    simple_requests_handler = SimpleRequestHandler(
+        dispatcher=dispatcher,
+        bot=bot,
+        secret_token=webhook_secret
+    )
+    simple_requests_handler.register(app, path=webhook_path)
+    setup_application(app, dispatcher, bot=bot)
+    web.run_app(
+        app=app,
+        host=webhook_server_hostname,
+        port=webhook_server_port
+    )
 
 
 def __example():

arpakitlib/ar_arpakit_project_template_util.py

@@ -13,21 +13,17 @@ _logger = logging.getLogger(__name__)
 
 def init_arpakit_project_template(
         *,
+        version: str = "1",
         project_dirpath: str = "./",
         overwrite_if_exists: bool = False,
         ignore_paths_startswith: list[str] | str | None = None,
         only_paths_startswith: list[str] | str | None = None,
-        params: dict[str, str] | None = None,
 ):
     raise_for_type(project_dirpath, str)
     raise_if_string_blank(project_dirpath)
 
     raise_for_type(overwrite_if_exists, bool)
 
-    if params is None:
-        params = {}
-    raise_for_type(params, dict)
-
     if isinstance(ignore_paths_startswith, str):
         ignore_paths_startswith = [ignore_paths_startswith]
     if ignore_paths_startswith is None:
@@ -40,9 +36,9 @@ def init_arpakit_project_template(
         only_paths_startswith = []
     raise_for_type(only_paths_startswith, list)
 
-    def _generate_filepath_to_content() -> dict[str, str]:
+    def _generate_filepath_to_content() -> dict[str, bytes]:
         arpakit_project_template_dirpath = os.path.join(
-            os.path.dirname(os.path.abspath(__file__)), "_arpakit_project_template"
+            os.path.dirname(os.path.abspath(__file__)), f"_arpakit_project_template_v_{version}"
         )
         res = {}
         for root, dirs, files in os.walk(arpakit_project_template_dirpath):
@@ -63,10 +59,8 @@ def init_arpakit_project_template(
                 ):
                     _logger.info(f"ignoring file: {rel_path}")
                     continue
-                with open(os.path.join(root, file), "r", encoding="utf-8") as _file:
+                with open(os.path.join(root, file), "rb") as _file:
                     _content = _file.read()
-                for key, value in params.items():
-                    _content = _content.replace("{{" + key.upper().strip() + "}}", value)
                 res[rel_path] = _content
         return res
 
@@ -84,6 +78,6 @@ def init_arpakit_project_template(
 
         _logger.info(f"creating file: {full_filepath}")
         os.makedirs(os.path.dirname(full_filepath), exist_ok=True)
-        with open(full_filepath, "w", encoding="utf-8") as file_:
+        with open(full_filepath, "wb") as file_:
             file_.write(content)
         _logger.info(f"file created: {full_filepath}")

arpakitlib/ar_arpakitlib_cli_util.py

@@ -26,6 +26,7 @@ def execute_arpakitlib_cli(*, full_command: str | None = None):
         print("Commands:")
         print()
         print("-c init_arpakit_project_template")
+        print("-version (1,) ...")
         print("-project_dirpath ./")
         print("-overwrite_if_exists ...")
         print("-ignore_paths_startswith ...")
@@ -36,6 +37,11 @@ def execute_arpakitlib_cli(*, full_command: str | None = None):
         print("\n")
 
     elif command == "init_arpakit_project_template":
+        version: str = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["version"]),
+            need_type=NeedTypes.str_,
+            allow_none=False
+        )
         project_dirpath: str = parse_need_type(
             value=parsed_command.get_value_by_keys(keys=["project_dirpath"]),
             need_type=NeedTypes.str_,
@@ -57,11 +63,11 @@ def execute_arpakitlib_cli(*, full_command: str | None = None):
             allow_none=True
         )
         init_arpakit_project_template(
+            version=version,
             project_dirpath=project_dirpath,
             overwrite_if_exists=overwrite_if_exists,
             ignore_paths_startswith=ignore_paths_startswith,
-            only_paths_startswith=only_paths_startswith,
-            params=parsed_command.key_to_value,
+            only_paths_startswith=only_paths_startswith
         )
 
     else:

arpakitlib/ar_base_worker_util.py

@@ -11,7 +11,7 @@ from typing import Any
 from uuid import uuid4
 
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_func_util import is_async_function, is_sync_function
+from arpakitlib.ar_func_util import is_async_callable, is_sync_function, is_async_object
 from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -22,20 +22,23 @@ class BaseWorker(ABC):
             self,
             *,
             timeout_after_run: timedelta = timedelta(seconds=0.3),
-            timeout_after_err_in_run: timedelta = timedelta(seconds=1),
+            timeout_after_error_in_run: timedelta = timedelta(seconds=1),
             startup_funcs: list[Any] | None = None,
             worker_name: str | None = None,
             **kwargs
     ):
         self.timeout_after_run = timeout_after_run
-        self.timeout_after_err_in_run = timeout_after_err_in_run
+        self.timeout_after_error_in_run = timeout_after_error_in_run
+
         if startup_funcs is None:
             startup_funcs = []
         self.startup_funcs = startup_funcs
+
         if worker_name is None:
             worker_name = self.__class__.__name__
         self.worker_name = worker_name
         self.worker_id = f"{str(uuid4()).replace('-', '')}_{randint(1000, 99999)}"
+
         self._logger = logging.getLogger(self.worker_fullname)
 
     @property
@@ -43,19 +46,26 @@ class BaseWorker(ABC):
         return f"{self.worker_name}_{self.worker_id}"
 
     def sync_run_startup_funcs(self):
+        self._logger.info("start")
         for startup_func in self.startup_funcs:
-            if is_async_function(startup_func):
+            if is_async_callable(startup_func):
                 asyncio.run(startup_func())
+            elif is_async_object(startup_func):
+                async def __func():
+                    await startup_func
+
+                asyncio.run(__func())
             elif is_sync_function(startup_func):
                 startup_func()
             else:
-                raise TypeError("no sync and not async")
+                raise TypeError("unknown startup_func type")
+        self._logger.info("finish")
 
     def sync_on_startup(self):
         self.sync_run_startup_funcs()
 
     def sync_run(self):
-        self._logger.info(f"hello world, im {self.worker_fullname}")
+        pass
 
     def sync_on_error(self, exception: Exception, **kwargs):
         pass
@@ -65,35 +75,39 @@ class BaseWorker(ABC):
         try:
             self.sync_on_startup()
         except Exception as exception:
-            self._logger.error("error in sync_on_startup", exc_info=exception)
+            self._logger.error("exception in sync_on_startup", exc_info=exception)
             raise
         while True:
             try:
                 self.sync_run()
             except Exception as exception:
-                self._logger.error("error in sync_run", exc_info=exception)
+                self._logger.error("exception in sync_run", exc_info=exception)
                 try:
                     self.sync_on_error(exception=exception)
                 except Exception as exception_:
-                    self._logger.error("error in sync_on_error", exc_info=exception_)
+                    self._logger.error("exception in sync_on_error", exc_info=exception_)
                     raise
-                sync_safe_sleep(self.timeout_after_err_in_run)
+                sync_safe_sleep(self.timeout_after_error_in_run)
             sync_safe_sleep(self.timeout_after_run)
 
     async def async_run_startup_funcs(self):
+        self._logger.info("start")
         for startup_func in self.startup_funcs:
-            if is_async_function(startup_func):
+            if is_async_callable(startup_func):
                 await startup_func()
+            elif is_async_object(startup_func):
+                await startup_func
             elif is_sync_function(startup_func):
                 startup_func()
             else:
-                raise TypeError("no sync and not async")
+                raise TypeError("unknown startup_func type")
+        self._logger.info("finish")
 
     async def async_on_startup(self):
         await self.async_run_startup_funcs()
 
     async def async_run(self):
-        self._logger.info(f"hello world, im {self.worker_fullname}")
+        pass
 
     async def async_on_error(self, exception: Exception, **kwargs):
         pass
@@ -103,19 +117,19 @@ class BaseWorker(ABC):
         try:
             await self.async_on_startup()
         except Exception as exception:
-            self._logger.error("error in async_on_startup", exc_info=exception)
+            self._logger.error("exception in async_on_startup", exc_info=exception)
             raise
         while True:
             try:
                 await self.async_run()
             except Exception as exception:
-                self._logger.error("error in async_run", exc_info=exception)
+                self._logger.error("exception in async_run", exc_info=exception)
                 try:
                     await self.async_on_error(exception=exception)
                 except Exception as exception_:
-                    self._logger.error("error in async_on_error", exc_info=exception_)
+                    self._logger.error("exception in async_on_error", exc_info=exception_)
                     raise
-                await async_safe_sleep(self.timeout_after_err_in_run)
+                await async_safe_sleep(self.timeout_after_error_in_run)
             await async_safe_sleep(self.timeout_after_run)
 
 
@@ -156,6 +170,10 @@ def safe_run_workers_in_background(
     return res
 
 
+async def a():
+    print("1")
+
+
 def __example():
     pass
 

arpakitlib/ar_class_util.py

@@ -14,3 +14,14 @@ class CollectingSubclassesMeta(type):
             cls.all_subclasses = []
         elif bases:
             cls.all_subclasses.append(cls)
+
+
+def create_combined_meta(*metas):
+    """
+    Создает объединённый метакласс для устранения конфликтов.
+    """
+
+    class CombinedMeta(*metas):
+        pass
+
+    return CombinedMeta