arpakitlib 1.8.155__tar.gz → 1.8.156__tar.gz

{arpakitlib-1.8.155 → arpakitlib-1.8.156}/PKG-INFO

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

{arpakitlib-1.8.155 → arpakitlib-1.8.156}/arpakitlib/_arpakit_project_template_v_5/project/sqlalchemy_db_/util/execute_func_with_story_log.py

@@ -3,17 +3,29 @@ import inspect
 import logging
 from typing import Any
 
+from pydantic import BaseModel, ConfigDict
 from sqlalchemy.ext.asyncio import AsyncSession
 from sqlalchemy.orm import Session
 
 from arpakitlib.ar_exception_util import exception_to_traceback_str
-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 StoryLogDBM
 
 _logger = logging.getLogger(__name__)
 
 
+class ExecuteWithStoryLogRes(BaseModel):
+    func_res: Any = None
+    story_log_dbm: StoryLogDBM | None = None
+    exception: Exception | None = None
+
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+
+    def raise_if_exception(self):
+        if self.exception is not None:
+            raise self.exception
+
+
 def sync_execute_with_story_log(
         func,
         *,
@@ -24,49 +36,60 @@ def sync_execute_with_story_log(
         story_log_type: str = StoryLogDBM.Types.error_in_execute_with_story_log,
         story_log_title: str | None = None,
         story_log_extra_data: dict[Any, Any] | None = None,
-) -> Any:
+        raise_if_exception: bool = False
+) -> ExecuteWithStoryLogRes:
     if func_args is None:
         func_args = tuple()
     if func_kwargs is None:
         func_kwargs = {}
     if story_log_extra_data is None:
         story_log_extra_data = {}
+    story_log_extra_data = story_log_extra_data.copy()
+
+    execute_with_story_log_res = ExecuteWithStoryLogRes()
 
     try:
-        return func(*func_args, **func_kwargs)
+        execute_with_story_log_res.func_res = func(*func_args, **func_kwargs)
+        return execute_with_story_log_res
     except Exception as exception:
         _logger.error(f"Error in {func.__name__}", exc_info=True)
 
+        execute_with_story_log_res.exception = exception
+
         if story_log_title is None:
             story_log_title = f"Error in func {func.__name__}: {type(exception).__name__}: {exception}"
         story_log_extra_data.update({
             "exception": str(exception),
             "exception_traceback": exception_to_traceback_str(exception=exception),
             "exception_type_name": type(exception).__name__,
-            "func_name": inspect.currentframe().f_code.co_name
+            "wrapper_func_name": inspect.currentframe().f_code.co_name,
+            "called_func_name": func.__name__
         })
 
         if session_ is not None:
-            story_log_dbm = StoryLogDBM(
+            execute_with_story_log_res.story_log_dbm = StoryLogDBM(
                 level=story_log_level,
                 type=story_log_type,
                 title=story_log_title,
                 extra_data=story_log_extra_data
             )
-            session_.add(story_log_dbm)
+            session_.add(execute_with_story_log_res.story_log_dbm)
             session_.commit()
         else:
             with get_cached_sqlalchemy_db().new_session() as session:
-                story_log_dbm = StoryLogDBM(
+                execute_with_story_log_res.story_log_dbm = StoryLogDBM(
                     level=story_log_level,
                     type=story_log_type,
                     title=story_log_title,
                     extra_data=story_log_extra_data
                 )
-                session.add(story_log_dbm)
+                session.add(execute_with_story_log_res.story_log_dbm)
                 session.commit()
 
-        raise exception
+        if raise_if_exception:
+            raise
+
+        return execute_with_story_log_res
 
 
 async def async_execute_with_story_log(
@@ -79,19 +102,26 @@ async def async_execute_with_story_log(
         story_log_type: str = StoryLogDBM.Types.error_in_execute_with_story_log,
         story_log_title: str | None = None,
         story_log_extra_data: dict[Any, Any] | None = None,
-) -> Any:
+        raise_if_exception: bool = False
+) -> ExecuteWithStoryLogRes:
     if async_func_args is None:
         async_func_args = ()
     if async_func_kwargs is None:
         async_func_kwargs = {}
     if story_log_extra_data is None:
         story_log_extra_data = {}
+    story_log_extra_data = story_log_extra_data.copy()
+
+    execute_with_story_log_res = ExecuteWithStoryLogRes()
 
     try:
-        return await async_func(*async_func_args, **async_func_kwargs)
+        execute_with_story_log_res.func_res = await async_func(*async_func_args, **async_func_kwargs)
+        return execute_with_story_log_res
     except Exception as exception:
         _logger.error(f"Async error in {async_func.__name__}", exc_info=True)
 
+        execute_with_story_log_res.exception = exception
+
         if story_log_title is None:
             story_log_title = f"Async error in func {async_func.__name__}: {type(exception).__name__}: {exception}"
 
@@ -99,51 +129,38 @@ async def async_execute_with_story_log(
             "exception": str(exception),
             "exception_traceback": exception_to_traceback_str(exception=exception),
             "exception_type_name": type(exception).__name__,
-            "func_name": inspect.currentframe().f_code.co_name
+            "wrapper_func_name": inspect.currentframe().f_code.co_name,
+            "called_func_name": async_func.__name__
         })
 
         if async_session_ is not None:
-            story_log_dbm = StoryLogDBM(
+            execute_with_story_log_res.story_log_dbm = StoryLogDBM(
                 level=story_log_level,
                 type=story_log_type,
                 title=story_log_title,
                 extra_data=story_log_extra_data
             )
-            async_session_.add(story_log_dbm)
+            async_session_.add(execute_with_story_log_res.story_log_dbm)
             await async_session_.commit()
         else:
             async with get_cached_sqlalchemy_db().new_async_session() as async_session:
-                story_log_dbm = StoryLogDBM(
+                execute_with_story_log_res.story_log_dbm = StoryLogDBM(
                     level=story_log_level,
                     type=story_log_type,
                     title=story_log_title,
                     extra_data=story_log_extra_data
                 )
-                async_session.add(story_log_dbm)
+                async_session.add(execute_with_story_log_res.story_log_dbm)
                 await async_session.commit()
 
-        raise exception
+        if raise_if_exception:
+            raise
 
+        return execute_with_story_log_res
 
-async def __async_example():
-    setup_logging()
-
-    def hello_world():
-        print(inspect.currentframe().f_code.co_name)
-        # raise ValueError("1111111")
 
-    print(hello_world())
-
-    # async def async_hello_world():
-    #     print(1)
-    #     raise ValueError("1111111")
-
-    # sync_execute_with_story_log(
-    #     func=hello_world
-    # )
-    # await async_execute_with_story_log(
-    #     func=async_hello_world
-    # )
+async def __async_example():
+    pass
 
 
 if __name__ == '__main__':

{arpakitlib-1.8.155 → arpakitlib-1.8.156}/arpakitlib/ar_sqlalchemy_util.py

@@ -220,6 +220,20 @@ class SQLAlchemyDb:
         self.remove_celery_tables_data()
         self._logger.info("all reinited")
 
+    def remove_rows_from_tables(self):
+        with self.new_session() as session:
+            for table_name, table in BaseDBM.metadata.tables.items():
+                session.execute(sqlalchemy.delete(table))
+            session.commit()
+        self._logger.info(f"rows from tables ({BaseDBM.metadata.tables.keys()}) were removed")
+
+    async def async_remove_rows_from_tables(self):
+        async with self.new_async_session() as async_session:
+            for table_name, table in BaseDBM.metadata.tables.items():
+                await async_session.execute(sqlalchemy.delete(table))
+            await async_session.commit()
+        self._logger.info(f"rows from tables ({BaseDBM.metadata.tables.keys()}) were removed")
+
     def check_conn(self):
         self.engine.connect()
         self._logger.info("db conn is good")

{arpakitlib-1.8.155 → arpakitlib-1.8.156}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.8.155"
+version = "1.8.156"
 description = "arpakitlib"
 authors = [
     { name = "arpakit_support", email = "support@arpakit.com" }