arpakitlib 1.7.227__tar.gz → 1.7.229__tar.gz

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.7.227
+Version: 1.7.229
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/arpakitlib/ar_arpakit_lib_module_util.py

@@ -15,7 +15,7 @@ class ArpakitLibModule(NamedTuple):
     module_content: str
     module_hash: str
     module_has_error: bool
-    module_exception: BaseException | None
+    module_exception: Exception | None
     filename: str
     filepath: str
 
@@ -85,7 +85,7 @@ class ArpakitLibModules(NamedTuple):
                 return True
         return False
 
-    def module_name_to_module_exception(self, *, filter_module_has_error: bool = False) -> dict[str, BaseException]:
+    def module_name_to_module_exception(self, *, filter_module_has_error: bool = False) -> dict[str, Exception]:
         if filter_module_has_error:
             return {
                 module.module_name: module.module_exception
@@ -124,7 +124,7 @@ def get_arpakit_lib_modules() -> ArpakitLibModules:
             module_version = getattr(module, "_ARPAKIT_LIB_MODULE_VERSION", None)
             module_has_error = False
             module_exception = None
-        except BaseException as error:
+        except Exception as error:
             module_has_error = True
             module_exception = error
         if module_version is not None and not isinstance(module_version, str):

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/arpakitlib/ar_base_worker_util.py

@@ -57,26 +57,26 @@ class BaseWorker(ABC):
     def sync_run(self):
         self._logger.info(f"hello world, im {self.worker_fullname}")
 
-    def sync_on_error(self, exception: BaseException, **kwargs):
+    def sync_on_error(self, exception: Exception, **kwargs):
         pass
 
     def sync_safe_run(self):
         self._logger.info("start")
         try:
             self.sync_on_startup()
-        except BaseException as exception:
+        except Exception as exception:
             self._logger.error("error in sync_on_startup", exc_info=exception)
-            raise exception
+            raise
         while True:
             try:
                 self.sync_run()
-            except BaseException as exception:
+            except Exception as exception:
                 self._logger.error("error in sync_run", exc_info=exception)
                 try:
                     self.sync_on_error(exception=exception)
-                except BaseException as exception_:
+                except Exception as exception_:
                     self._logger.error("error in sync_on_error", exc_info=exception_)
-                    raise exception_
+                    raise
                 sync_safe_sleep(self.timeout_after_err_in_run)
             sync_safe_sleep(self.timeout_after_run)
 
@@ -95,26 +95,26 @@ class BaseWorker(ABC):
     async def async_run(self):
         self._logger.info(f"hello world, im {self.worker_fullname}")
 
-    async def async_on_error(self, exception: BaseException, **kwargs):
+    async def async_on_error(self, exception: Exception, **kwargs):
         pass
 
     async def async_safe_run(self):
         self._logger.info("start async_safe_run")
         try:
             await self.async_on_startup()
-        except BaseException as exception:
+        except Exception as exception:
             self._logger.error("error in async_on_startup", exc_info=exception)
-            raise exception
+            raise
         while True:
             try:
                 await self.async_run()
-            except BaseException as exception:
+            except Exception as exception:
                 self._logger.error("error in async_run", exc_info=exception)
                 try:
                     await self.async_on_error(exception=exception)
-                except BaseException as exception_:
+                except Exception as exception_:
                     self._logger.error("error in async_on_error", exc_info=exception_)
-                    raise exception_
+                    raise
                 await async_safe_sleep(self.timeout_after_err_in_run)
             await async_safe_sleep(self.timeout_after_run)
 

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/arpakitlib/ar_http_request_util.py

@@ -69,7 +69,7 @@ def sync_make_http_request(
             if enable_logging_:
                 _logger.info(f"good try http {method} {url} {params}")
             return response
-        except BaseException as exception:
+        except Exception as exception:
             if enable_logging_:
                 _logger.warning(
                     f"{tries_counter}/{max_tries_}. retry {method} {url} {params}, exception={exception}"
@@ -131,7 +131,7 @@ async def async_make_http_request(
                     if enable_logging_:
                         _logger.info(f"good try http {method} {url} {params}")
                     return response
-        except BaseException as exception:
+        except Exception as exception:
             if enable_logging_:
                 _logger.warning(
                     f"{tries_counter}/{max_tries_}. retry http {method} {url} {params}, exception={exception}"

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/arpakitlib/ar_operation_execution_util.py

@@ -173,12 +173,12 @@ class BaseOperationExecutor:
         )
         session.commit()
 
-        exception: BaseException | None = None
+        exception: Exception | None = None
         traceback_str: str | None = None
 
         try:
             self.sync_execute_operation(operation_dbm=operation_dbm, session=session)
-        except BaseException as exception_:
+        except Exception as exception_:
             self._logger.error(
                 f"error in sync_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
                 exc_info=exception_
@@ -253,12 +253,12 @@ class BaseOperationExecutor:
         )
         session.commit()
 
-        exception: BaseException | None = None
+        exception: Exception | None = None
         traceback_str: str | None = None
 
         try:
             await self.async_execute_operation(operation_dbm=operation_dbm, session=session)
-        except BaseException as exception_:
+        except Exception as exception_:
             self._logger.error(
                 f"error in async_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
                 exc_info=exception_

arpakitlib-1.7.229/arpakitlib/ar_rat_func_util.py

@@ -0,0 +1,77 @@
+from typing import Any
+
+from pydantic import BaseModel, ConfigDict
+
+from arpakitlib.ar_type_util import NotSet, is_set, is_not_set
+
+
+class RatFuncRes(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    func_res: Any = NotSet
+    func_exception: Exception | None = None
+
+    def raise_for_func_exception(self):
+        if self.func_exception is not None:
+            raise self.func_exception
+
+    @property
+    def has_exception(self) -> bool:
+        if self.func_exception is not None:
+            return True
+        return False
+
+    @property
+    def is_func_res_set(self) -> bool:
+        return is_set(self.func_res)
+
+    @property
+    def is_func_res_not_set(self) -> bool:
+        return is_not_set(self.func_res)
+
+
+def rat_sync_func(
+        *,
+        sync_func: Any,
+        sync_func_args: tuple[Any, ...] | None = None,
+        sync_func_kwargs: dict[str, Any] | None = None,
+) -> RatFuncRes:
+    sync_func_args = sync_func_args or ()
+    sync_func_kwargs = sync_func_kwargs or {}
+    rat_func_res = RatFuncRes()
+    try:
+        rat_func_res.func_res = sync_func(*sync_func_args, **sync_func_kwargs)
+    except Exception as exception:
+        rat_func_res.func_exception = exception
+    return rat_func_res
+
+
+async def rat_async_func(
+        *,
+        async_func: Any,
+        async_func_args: tuple[Any, ...] | None = None,
+        async_func_kwargs: dict[str, Any] | None = None,
+) -> RatFuncRes:
+    async_func_args = async_func_args or ()
+    async_func_kwargs = async_func_kwargs or {}
+    rat_func_res = RatFuncRes()
+    try:
+        rat_func_res.func_res = await async_func(*async_func_args, **async_func_kwargs)
+    except Exception as exception:
+        rat_func_res.func_exception = exception
+    return rat_func_res
+
+
+def __example():
+    def go():
+        return "asfaf"
+
+    a = rat_sync_func(sync_func=go)
+    print(a.has_exception)
+    print(a)
+    print(a.is_func_res_set)
+    print(a.is_func_res_not_set)
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib-1.7.229/arpakitlib/ar_retry_func_util.py

@@ -0,0 +1,76 @@
+import asyncio
+from datetime import timedelta
+from typing import Any
+
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
+
+
+async def async_retry_func(
+        *,
+        async_func: Any,
+        async_func_args: tuple[Any, ...] | None = None,
+        async_func_kwargs: dict[str, Any] | None = None,
+        max_tries: int = 5,
+        endlessly: bool = False,
+        timeout_after_exception: timedelta | None = None,
+        raise_if_exception: bool = True
+):
+    tries = 0
+    async_func_args = async_func_args or ()
+    async_func_kwargs = async_func_kwargs or {}
+
+    while True:
+        try:
+            return await async_func(*async_func_args, **async_func_kwargs)
+        except Exception:
+            tries += 1
+            if not endlessly and tries >= max_tries:
+                if raise_if_exception:
+                    raise
+                return None
+            if timeout_after_exception:
+                await async_safe_sleep(timeout_after_exception.total_seconds())
+
+
+def sync_retry_func(
+        *,
+        sync_func: Any,
+        sync_func_args: tuple[Any, ...] | None = None,
+        sync_func_kwargs: dict[str, Any] | None = None,
+        max_tries: int = 5,
+        endlessly: bool = False,
+        timeout_after_exception: timedelta | None = None,
+        raise_if_exception: bool = True
+):
+    tries = 0
+    sync_func_args = sync_func_args or ()
+    sync_func_kwargs = sync_func_kwargs or {}
+
+    while True:
+        try:
+            return sync_func(*sync_func_args, **sync_func_kwargs)
+        except Exception:
+            tries += 1
+            if not endlessly and tries >= max_tries:
+                if raise_if_exception:
+                    raise
+                return None
+            if timeout_after_exception:
+                sync_safe_sleep(timeout_after_exception.total_seconds())
+
+
+async def __async_example():
+    async def g():
+        print(1)
+        raise Exception
+
+    await async_retry_func(
+        async_func=g,
+        endlessly=True,
+        max_tries=5,
+        timeout_after_exception=timedelta(seconds=1)
+    )
+
+
+if __name__ == '__main__':
+    asyncio.run(__async_example())

{arpakitlib-1.7.227 → arpakitlib-1.7.229}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.7.227"
+version = "1.7.229"
 description = "arpakitlib"
 authors = [
     { name = "arpakit", email = "arpakit@gmail.com" },