arpakitlib 1.7.62__tar.gz → 1.7.64__tar.gz

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arpakitlib
-Version: 1.7.62
+Version: 1.7.64
 Summary: arpakitlib
 Home-page: https://github.com/ARPAKIT-Company/arpakitlib
 License: Apache-2.0

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/arpakitlib/ar_base_worker_util.py

@@ -14,49 +14,23 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
 class BaseWorker(ABC):
-    class SafeRunInBackgroundModes(Enumeration):
-        async_task = "async_task"
-        thread = "thread"
-        process = "process"
-
     def __init__(self):
         self.worker_name = self.__class__.__name__
         self._logger = logging.getLogger(self.worker_name)
         self.timeout_after_run = timedelta(seconds=0.1).total_seconds()
         self.timeout_after_err_in_run = timedelta(seconds=1).total_seconds()
 
-    def safe_run_in_background(self, *, safe_run_in_background_mode: str) -> (
-            asyncio.Task | threading.Thread | multiprocessing.Process
-    ):
-        if safe_run_in_background_mode == self.SafeRunInBackgroundModes.async_task:
-            res: asyncio.Task = asyncio.create_task(self.async_safe_run())
-        elif safe_run_in_background_mode == self.SafeRunInBackgroundModes.thread:
-            res: threading.Thread = threading.Thread(
-                target=self.sync_safe_run,
-                daemon=True
-            )
-            res.start()
-        elif safe_run_in_background_mode == self.SafeRunInBackgroundModes.process:
-            res: multiprocessing.Process = multiprocessing.Process(
-                target=self.sync_safe_run,
-                daemon=True
-            )
-            res.start()
-        else:
-            raise ValueError(f"unknown safe_run_mode={safe_run_in_background_mode}")
-        return res
-
     def sync_on_startup(self):
         pass
 
     def sync_run(self):
-        raise NotImplementedError()
+        self._logger.info("hello world")
 
     def sync_run_on_error(self, exception: BaseException, **kwargs):
         pass
 
     def sync_safe_run(self):
-        self._logger.info("start sync_safe_run")
+        self._logger.info("start")
         try:
             self.sync_on_startup()
         except BaseException as exception:
@@ -65,8 +39,6 @@ class BaseWorker(ABC):
         while True:
             try:
                 self.sync_run()
-                if self.timeout_after_run is not None:
-                    sync_safe_sleep(self.timeout_after_run)
             except BaseException as exception:
                 self._logger.error("error in sync_run", exc_info=exception)
                 try:
@@ -74,14 +46,14 @@ class BaseWorker(ABC):
                 except BaseException as exception_:
                     self._logger.error("error in sync_run_on_error", exc_info=exception_)
                     raise exception_
-                if self.timeout_after_err_in_run is not None:
-                    sync_safe_sleep(self.timeout_after_err_in_run)
+            if self.timeout_after_run is not None:
+                sync_safe_sleep(self.timeout_after_run)
 
     async def async_on_startup(self):
         pass
 
     async def async_run(self):
-        raise NotImplementedError()
+        self._logger.info("hello world")
 
     async def async_run_on_error(self, exception: BaseException, **kwargs):
         pass
@@ -96,8 +68,6 @@ class BaseWorker(ABC):
         while True:
             try:
                 await self.async_run()
-                if self.timeout_after_run is not None:
-                    await async_safe_sleep(self.timeout_after_run)
             except BaseException as exception:
                 self._logger.error("error in async_run", exc_info=exception)
                 try:
@@ -105,8 +75,36 @@ class BaseWorker(ABC):
                 except BaseException as exception_:
                     self._logger.error("error in async_run_on_error", exc_info=exception_)
                     raise exception_
-                if self.timeout_after_err_in_run is not None:
-                    await async_safe_sleep(self.timeout_after_err_in_run)
+            if self.timeout_after_err_in_run is not None:
+                await async_safe_sleep(self.timeout_after_err_in_run)
+
+
+class SafeRunInBackgroundModes(Enumeration):
+    async_task = "async_task"
+    thread = "thread"
+    process = "process"
+
+
+def safe_run_worker_in_background(*, worker: BaseWorker, mode: str) -> (
+        asyncio.Task | threading.Thread | multiprocessing.Process
+):
+    if mode == SafeRunInBackgroundModes.async_task:
+        res: asyncio.Task = asyncio.create_task(worker.async_safe_run())
+    elif mode == SafeRunInBackgroundModes.thread:
+        res: threading.Thread = threading.Thread(
+            target=worker.sync_safe_run,
+            daemon=True
+        )
+        res.start()
+    elif mode == SafeRunInBackgroundModes.process:
+        res: multiprocessing.Process = multiprocessing.Process(
+            target=worker.sync_safe_run,
+            daemon=True
+        )
+        res.start()
+    else:
+        raise ValueError(f"unknown safe_run_mode={mode}")
+    return res
 
 
 def __example():

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/arpakitlib/ar_fastapi_util.py

@@ -176,6 +176,7 @@ def create_handle_exception(
                 "exception_str": str(exception),
                 "request.method": str(request.method),
                 "request.url": str(request.url),
+                "request.headers": str(request.headers),
             }
         )
 
@@ -254,7 +255,8 @@ def create_handle_exception(
 
 def create_story_log_before_response_in_handle_exception(
         *,
-        sqlalchemy_db: SQLAlchemyDB
+        sqlalchemy_db: SQLAlchemyDB,
+        ignore_api_error_code_not_found: bool = True
 ) -> Callable:
     def func(
             *,
@@ -264,6 +266,8 @@ def create_story_log_before_response_in_handle_exception(
             exception: Exception,
             **kwargs
     ) -> (int, ErrorSO, dict[str, Any]):
+        if ignore_api_error_code_not_found and error_so.error_code == BaseAPIErrorCodes.not_found:
+            return status_code, error_so, kwargs
         sqlalchemy_db.init()
         traceback_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
         with sqlalchemy_db.new_session() as session:

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/arpakitlib/ar_logging_util.py

@@ -2,7 +2,6 @@
 
 import logging
 import os
-from functools import wraps
 from typing import Optional
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -34,7 +33,7 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
     stream_handler = logging.StreamHandler()
     stream_handler.setLevel(logging.INFO)
     stream_formatter = logging.Formatter(
-        "%(asctime)s | %(levelname)s | %(name)s | %(filename)s:%(funcName)s:%(lineno)d - %(message)s",
+        "%(asctime)s | %(levelname)s | %(filename)s | %(name)s:%(funcName)s:%(lineno)d - %(message)s",
         datefmt="%d.%m.%Y %I:%M:%S%p"
     )
     stream_handler.setFormatter(stream_formatter)
@@ -44,7 +43,7 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
         file_handler = logging.FileHandler(log_filepath)
         file_handler.setLevel(logging.WARNING)
         file_formatter = logging.Formatter(
-            "%(asctime)s | %(levelname)s | %(name)s | %(filename)s:%(funcName)s:%(lineno)d - %(message)s",
+            "%(asctime)s | %(levelname)s | %(filename)s | %(name)s:%(funcName)s:%(lineno)d - %(message)s",
             datefmt="%d.%m.%Y %I:%M:%S%p"
         )
         file_handler.setFormatter(file_formatter)
@@ -55,38 +54,6 @@ def setup_normal_logging(log_filepath: Optional[str] = None):
     logger.info("normal logging was setup")
 
 
-def log_func():
-    def decorator(func):
-        @wraps(func)
-        def wrapper(*args, **kwargs):
-            function_path = f"{func.__module__}:{func.__qualname__}"
-            logger = logging.getLogger(__name__)
-            logger.info(f"start func {function_path}")
-            result = func(*args, **kwargs)
-            logger.info(f"finish func {function_path}")
-            return result
-
-        return wrapper
-
-    return decorator
-
-
-def log_async_func():
-    def decorator(func):
-        @wraps(func)
-        async def async_wrapper(*args, **kwargs):
-            function_path = f"{func.__module__}:{func.__qualname__}"
-            logger = logging.getLogger(__name__)
-            logger.info(f"start async func {function_path}")
-            result = await func(*args, **kwargs)
-            logger.info(f"finish async func {function_path}")
-            return result
-
-        return async_wrapper
-
-    return decorator
-
-
 def __example():
     pass
 

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/arpakitlib/ar_operation_execution_util.py

@@ -136,11 +136,17 @@ class BaseOperationExecutor:
         elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
+        else:
+            raise Exception(
+                f"unknown operation_dbm.type,"
+                f" operation_dbm.id={operation_dbm.id},"
+                f" operation_dbm.type={operation_dbm.type}"
+            )
         return operation_dbm
 
     def sync_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         self._logger.info(
-            f"start sync_safe_execute_operation, "
+            f"start "
             f"operation_dbm.id={operation_dbm.id}, "
             f"operation_dbm.type={operation_dbm.type}, "
             f"operation_dbm.status={operation_dbm.status}"
@@ -219,11 +225,17 @@ class BaseOperationExecutor:
         elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
+        else:
+            raise Exception(
+                f"unknown operation_dbm.type,"
+                f" operation_dbm.id={operation_dbm.id},"
+                f" operation_dbm.type={operation_dbm.type}"
+            )
         return operation_dbm
 
     async def async_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         self._logger.info(
-            f"start async_safe_execute_operation, "
+            f"start "
             f"operation_dbm.id={operation_dbm.id}, "
             f"operation_dbm.type={operation_dbm.type}, "
             f"operation_dbm.status={operation_dbm.status}"

{arpakitlib-1.7.62 → arpakitlib-1.7.64}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arpakitlib"
-version = "1.7.62"
+version = "1.7.64"
 description = "arpakitlib"
 authors = ["arpakit <arpakit@gmail.com>", "arpakit_support <support@arpakit.com>"]
 license = "Apache License 2.0"