arpakitlib 1.7.256__py3-none-any.whl → 1.8.0__py3-none-any.whl

arpakitlib/_arpakit_project_template_v1/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_v1/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.util import get_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_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_v1/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,33 +13,32 @@ _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:
         ignore_paths_startswith = []
+    raise_for_type(ignore_paths_startswith, list)
 
     if isinstance(only_paths_startswith, str):
         only_paths_startswith = [only_paths_startswith]
     if only_paths_startswith is None:
         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):
@@ -60,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
 
@@ -81,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

@@ -5,7 +5,6 @@ import sys
 from arpakitlib.ar_arpakit_project_template_util import init_arpakit_project_template
 from arpakitlib.ar_need_type_util import parse_need_type, NeedTypes
 from arpakitlib.ar_parse_command import parse_command
-from arpakitlib.ar_str_util import raise_if_string_blank
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -27,6 +26,8 @@ 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 ...")
         print("-only_paths_startswith ...")
@@ -36,13 +37,21 @@ def execute_arpakitlib_cli(*, full_command: str | None = None):
         print("\n")
 
     elif command == "init_arpakit_project_template":
-        project_dirpath = raise_if_string_blank(parsed_command.get_value_by_keys(keys=["project_dirpath"]))
+        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_,
+            allow_none=False
+        )
         overwrite_if_exists: bool = parse_need_type(
             value=parsed_command.get_value_by_keys(keys=["overwrite_if_exists"]),
             need_type=NeedTypes.bool_,
             allow_none=False
         )
-        params = parsed_command.key_to_value
         ignore_paths_startswith: list[str] | None = parse_need_type(
             value=parsed_command.get_value_by_keys(keys=["ignore_paths_startswith"]),
             need_type=NeedTypes.list_of_str,
@@ -54,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=params,
+            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

arpakitlib/ar_func_util.py

@@ -5,50 +5,40 @@ from typing import Callable
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-def is_async_function(func: Callable) -> bool:
-    return asyncio.iscoroutinefunction(func)
+def is_async_callable(obj: Callable) -> bool:
+    if inspect.ismethod(obj) or inspect.isfunction(obj):
+        return inspect.iscoroutinefunction(obj)
+    if isinstance(obj, (staticmethod, classmethod)):
+        return inspect.iscoroutinefunction(obj.__func__)
+    return False
 
 
-def is_async_object(obj: object) -> bool:
-    return asyncio.iscoroutine(obj)
+def raise_if_not_async_callable(obj: Callable):
+    if not is_async_callable(obj):
+        raise TypeError(f"The provided callable '{obj.__name__}' is not an async")
 
 
-def is_sync_function(func: Callable) -> bool:
-    return inspect.isfunction(func) and not is_async_function(func)
+# ---
 
 
-def raise_if_not_async_func(func: Callable):
-    if not is_async_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
+def is_async_object(obj: object) -> bool:
+    return asyncio.iscoroutine(obj)
 
 
-def raise_if_not_sync_func(func: Callable):
-    if not is_sync_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' is not a sync function")
+# ---
 
 
-def raise_if_async_func(func: Callable):
-    if is_async_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' should not be async")
+def is_sync_function(obj: Callable) -> bool:
+    return callable(obj) and not is_async_callable(obj=obj)
 
 
-def raise_if_sync_func(func: Callable):
-    if is_sync_function(func):
-        raise TypeError(f"The provided function '{func.__name__}' should not be sync")
+def raise_if_not_sync_callable(obj: Callable):
+    if not is_sync_function(obj):
+        raise TypeError(f"The provided callable '{obj.__name__}' is not an sync")
 
 
 def __example():
-    def one():
-        pass
-
-    async def two():
-        pass
-
-    print(is_sync_function(one))
-    print(is_sync_function(two))
-
-    print(is_async_function(one))
-    print(is_async_function(two))
+    pass
 
 
 if __name__ == '__main__':

arpakitlib/ar_http_request_util.py

@@ -29,6 +29,7 @@ def sync_make_http_request(
         not_raise_for_statuses_: list[int] | None = None,
         timeout_: timedelta | float = timedelta(seconds=15).total_seconds(),
         enable_logging_: bool = False,
+        exception_class_: type[Exception] | None = None,
         **kwargs
 ) -> requests.Response:
     if isinstance(timeout_, float):
@@ -75,7 +76,10 @@ def sync_make_http_request(
                     f"{tries_counter}/{max_tries_}, bad try {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
-                raise exception
+                if exception_class_ is not None:
+                    raise exception_class_(exception)
+                else:
+                    raise exception
             sync_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 
@@ -92,6 +96,7 @@ async def async_make_http_request(
         not_raise_for_statuses_: list[int] | None = None,
         timeout_: timedelta | None = timedelta(seconds=15),
         enable_logging_: bool = False,
+        exception_class_: type[Exception] | None = None,
         **kwargs
 ) -> aiohttp.ClientResponse:
     tries_counter = 0
@@ -137,7 +142,10 @@ async def async_make_http_request(
                     f"{tries_counter}/{max_tries_}, bad try {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
-                raise exception
+                if exception_class_ is not None:
+                    raise exception_class_(exception)
+                else:
+                    raise exception
             await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 

arpakitlib/ar_need_type_util.py

@@ -23,6 +23,9 @@ def parse_need_type(value: Any, need_type: str, allow_none: bool = False) -> Any
     if allow_none and value is None:
         return None
 
+    if not allow_none and value is None:
+        raise ValueError("value is None")
+
     NeedTypes.parse_and_validate_values(need_type)
 
     if need_type == NeedTypes.str_:

arpakitlib/ar_rat_func_util.py

@@ -64,7 +64,7 @@ async def rat_async_func(
 
 def __example():
     def go():
-        return "asfaf"
+        return "go"
 
     a = rat_sync_func(sync_func=go)
     print(a.has_exception)