arpakitlib 1.5.34__py3-none-any.whl → 1.5.37__py3-none-any.whl

arpakitlib/ar_arpakit_schedule_uust_api_client.py

@@ -16,7 +16,7 @@ from aiohttp import ClientResponse, ClientTimeout, ClientResponseError
 from pydantic import ConfigDict, BaseModel
 
 from arpakitlib.ar_dict_util import combine_dicts
-from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_enumeration_util import Enumeration
 from arpakitlib.ar_json_util import safely_transfer_to_json_str
 from arpakitlib.ar_sleep_util import async_safe_sleep
 from arpakitlib.ar_type_util import raise_for_type
@@ -24,7 +24,7 @@ from arpakitlib.ar_type_util import raise_for_type
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-class Weekdays(EasyEnumeration):
+class Weekdays(Enumeration):
     monday = 1
     tuesday = 2
     wednesday = 3
@@ -34,7 +34,7 @@ class Weekdays(EasyEnumeration):
     sunday = 7
 
 
-class Months(EasyEnumeration):
+class Months(Enumeration):
     january = 1
     february = 2
     march = 3

arpakitlib/{ar_enumeration.py → ar_enumeration_util.py}

@@ -8,7 +8,7 @@ ValueType = Union[int, str]
 ValuesForParseType = Union[ValueType, Iterable[ValueType]]
 
 
-class EasyEnumeration:
+class Enumeration:
     @classmethod
     def iter_values(cls) -> Iterator[ValueType]:
         big_dict = {}

arpakitlib/ar_fastapi_util.py

@@ -6,6 +6,8 @@ import asyncio
 import logging
 import os.path
 import pathlib
+import threading
+import traceback
 from datetime import datetime
 from typing import Any, Callable
 
@@ -14,21 +16,28 @@ import fastapi.responses
 import starlette.exceptions
 import starlette.requests
 import starlette.status
-from fastapi import FastAPI
+from fastapi import FastAPI, APIRouter, Query
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
+from jaraco.context import suppress
 from pydantic import BaseModel, ConfigDict
 from starlette.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
 
-from arpakitlib.ar_easy_sqlalchemy_util import EasySQLAlchemyDB
-from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_json_util import safely_transfer_to_json_str_to_json_obj
+from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_operation_execution_util import ExecuteOperationWorker
+from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+from arpakitlib.ar_type_util import raise_for_type, raise_if_not_async_func
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 _logger = logging.getLogger(__name__)
 
 
-class BaseAPISchema(BaseModel):
+class BaseSchema(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
     @classmethod
@@ -43,26 +52,22 @@ class BaseAPISchema(BaseModel):
         super().__init_subclass__(**kwargs)
 
 
-class BaseAPISI(BaseAPISchema):
+class BaseSI(BaseSchema):
     pass
 
 
-class BaseAPISO(BaseAPISchema):
+class BaseSO(BaseSchema):
     pass
 
 
-class APISimpleDataSO(BaseAPISO):
-    data: dict[str, Any] = {}
-
-
-class BaseAPISimpleSO(BaseAPISO):
+class SimpleSO(BaseSO):
     id: int
     long_id: str
     creation_dt: datetime
 
 
-class APIErrorSO(BaseAPISO):
-    class APIErrorCodes(EasyEnumeration):
+class ErrorSO(BaseSO):
+    class APIErrorCodes(Enumeration):
         cannot_authorize = "CANNOT_AUTHORIZE"
         unknown_error = "UNKNOWN_ERROR"
         error_in_request = "ERROR_IN_REQUEST"
@@ -75,10 +80,33 @@ class APIErrorSO(BaseAPISO):
     error_data: dict[str, Any] = {}
 
 
+class RawDataSO(BaseSO):
+    data: dict[str, Any] = {}
+
+
+class StoryLogSO(SimpleSO):
+    level: str
+    title: str | None
+    data: dict[str, Any]
+
+
+class OperationSO(SimpleSO):
+    execution_start_dt: datetime | None
+    execution_finish_dt: datetime | None
+    status: str
+    type: str
+    input_data: dict[str, Any]
+    output_data: dict[str, Any]
+    error_data: dict[str, Any]
+    duration_total_seconds: float | None
+
+
 class APIJSONResponse(fastapi.responses.JSONResponse):
-    def __init__(self, *, content: BaseAPISO, status_code: int = starlette.status.HTTP_200_OK):
+    def __init__(self, *, content: BaseSO, status_code: int = starlette.status.HTTP_200_OK):
+        self.content_ = content
+        self.status_code_ = status_code
         super().__init__(
-            content=content.model_dump(mode="json"),
+            content=safely_transfer_to_json_str_to_json_obj(content.model_dump()),
             status_code=status_code
         )
 
@@ -88,7 +116,7 @@ class APIException(fastapi.exceptions.HTTPException):
             self,
             *,
             status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
-            error_code: str | None = APIErrorSO.APIErrorCodes.unknown_error,
+            error_code: str | None = ErrorSO.APIErrorCodes.unknown_error,
             error_code_specification: str | None = None,
             error_description: str | None = None,
             error_data: dict[str, Any] | None = None
@@ -101,7 +129,7 @@ class APIException(fastapi.exceptions.HTTPException):
             error_data = {}
         self.error_data = error_data
 
-        self.api_error_so = APIErrorSO(
+        self.error_so = ErrorSO(
             has_error=True,
             error_code=self.error_code,
             error_specification=self.error_code_specification,
@@ -111,142 +139,240 @@ class APIException(fastapi.exceptions.HTTPException):
 
         super().__init__(
             status_code=self.status_code,
-            detail=self.api_error_so.model_dump(mode="json")
+            detail=self.error_so.model_dump(mode="json")
         )
 
 
-def simple_api_handle_exception(request: starlette.requests.Request, exception: Exception) -> APIJSONResponse:
-    return from_exception_to_api_json_response(request=request, exception=exception)
-
-
-def from_exception_to_api_json_response(
-        request: starlette.requests.Request, exception: Exception
-) -> APIJSONResponse:
-    _logger.exception(exception)
-
-    easy_api_error_so = APIErrorSO(
-        has_error=True,
-        error_code=APIErrorSO.APIErrorCodes.unknown_error
-    )
+def create_handle_exception(
+        *,
+        funcs_before_response: list[Callable] | None = None,
+        async_funcs_after_response: list[Callable] | None = None,
+) -> Any:
+    if funcs_before_response is None:
+        funcs_before_response = []
+
+    if async_funcs_after_response is None:
+        async_funcs_after_response = []
+
+    async def handle_exception(
+            request: starlette.requests.Request, exception: Exception
+    ) -> APIJSONResponse:
+        status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
 
-    status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+        error_so = ErrorSO(
+            has_error=True,
+            error_code=ErrorSO.APIErrorCodes.unknown_error,
+            error_data={
+                "exception_type": str(type(exception)),
+                "exception_str": str(exception),
+                "request.method": str(request.method),
+                "request.url": str(request.url),
+            }
+        )
 
-    if isinstance(exception, APIException):
-        easy_api_error_so = exception.api_error_so
+        if isinstance(exception, APIException):
+            old_error_data = error_so.error_data
+            error_so = exception.error_so
+            error_so.error_data = combine_dicts(old_error_data, error_so.error_data)
+            _need_exc_info = False
+
+        elif isinstance(exception, starlette.exceptions.HTTPException):
+            status_code = exception.status_code
+            if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
+                error_so.error_code = ErrorSO.APIErrorCodes.cannot_authorize
+                _need_exc_info = False
+            elif status_code == starlette.status.HTTP_404_NOT_FOUND:
+                error_so.error_code = ErrorSO.APIErrorCodes.not_found
+                _need_exc_info = False
+            else:
+                status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+                _need_exc_info = True
+            with suppress(Exception):
+                error_so.error_data["exception.detail"] = exception.detail
+
+        elif isinstance(exception, fastapi.exceptions.RequestValidationError):
+            status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
+            error_so.error_code = ErrorSO.APIErrorCodes.error_in_request
+            with suppress(Exception):
+                error_so.error_data["exception.errors"] = str(exception.errors()) if exception.errors() else {}
+            _need_exc_info = False
 
-    elif isinstance(exception, starlette.exceptions.HTTPException):
-        status_code = exception.status_code
-        if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
-            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.cannot_authorize
-        elif status_code == starlette.status.HTTP_404_NOT_FOUND:
-            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.not_found
         else:
-            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.unknown_error
-        if (
-                isinstance(exception.detail, dict)
-                or isinstance(exception.detail, list)
-                or isinstance(exception.detail, str)
-                or isinstance(exception.detail, int)
-                or isinstance(exception.detail, float)
-                or isinstance(exception.detail, bool)
-        ):
-            easy_api_error_so.error_data["raw"] = exception.detail
+            status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+            error_so.error_code = ErrorSO.APIErrorCodes.unknown_error
+            _logger.exception(exception)
+            _need_exc_info = True
 
-    elif isinstance(exception, fastapi.exceptions.RequestValidationError):
-        status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
-        easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.error_in_request
-        easy_api_error_so.error_data["raw"] = str(exception.errors()) if exception.errors() else {}
+        if error_so.error_code:
+            error_so.error_code = error_so.error_code.upper().replace(" ", "_").strip()
 
-    else:
-        status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
-        easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.unknown_error
-        easy_api_error_so.error_data["raw"] = str(exception)
-        _logger.exception(exception)
-
-    if easy_api_error_so.error_code:
-        easy_api_error_so.error_code = easy_api_error_so.error_code.upper().replace(" ", "_").strip()
+        if error_so.error_code_specification:
+            error_so.error_code_specification = (
+                error_so.error_code_specification.upper().replace(" ", "_").strip()
+            )
 
-    if easy_api_error_so.error_code_specification:
-        easy_api_error_so.error_code_specification = (
-            easy_api_error_so.error_code_specification.upper().replace(" ", "_").strip()
+        if _need_exc_info:
+            _logger.error(str(exception), exc_info=exception)
+        else:
+            _logger.error(str(exception))
+
+        _kwargs = {}
+        for func in funcs_before_response:
+            data = func(
+                error_so=error_so, status_code=status_code, request=request, exception=exception, **_kwargs
+            )
+            if asyncio.iscoroutine(data):
+                data = await data
+            if data is not None:
+                status_code, error_so, _kwargs = data[0], data[1], data[2]
+                raise_for_type(status_code, int)
+                raise_for_type(error_so, ErrorSO)
+                raise_for_type(_kwargs, dict)
+
+        for async_func_after_response in async_funcs_after_response:
+            raise_if_not_async_func(async_func_after_response)
+            _ = asyncio.create_task(async_func_after_response(
+                error_so=error_so, status_code=status_code, request=request, exception=exception
+            ))
+
+        return APIJSONResponse(
+            content=error_so,
+            status_code=status_code
         )
 
-    return APIJSONResponse(
-        content=easy_api_error_so,
-        status_code=status_code
-    )
+    return handle_exception
 
 
-def add_exception_handler_to_fastapi_app(*, fastapi_app: FastAPI, api_handle_exception_: Callable) -> FastAPI:
-    fastapi_app.add_exception_handler(
+def create_handle_exception_creating_story_log(
+        *,
+        sqlalchemy_db: SQLAlchemyDB
+) -> Callable:
+    def handle_exception(
+            *,
+            error_so: ErrorSO,
+            status_code: int,
+            request: starlette.requests.Request,
+            exception: Exception,
+            **kwargs
+    ) -> (int, ErrorSO, dict[str, Any]):
+        sqlalchemy_db.init()
+        traceback_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+        with sqlalchemy_db.new_session() as session:
+            story_log_dbm = StoryLogDBM(
+                level=StoryLogDBM.Levels.error,
+                title=str(exception),
+                data={
+                    "error_so": error_so.model_dump(),
+                    "traceback_str": traceback_str
+                }
+            )
+            session.add(story_log_dbm)
+            session.commit()
+            session.refresh(story_log_dbm)
+        error_so.error_data.update({"story_log_long_id": story_log_dbm.long_id})
+        kwargs["story_log_id"] = story_log_dbm.id
+        return status_code, error_so, kwargs
+
+    return handle_exception
+
+
+def add_exception_handler_to_app(*, app: FastAPI, handle_exception: Callable) -> FastAPI:
+    app.add_exception_handler(
         exc_class_or_status_code=Exception,
-        handler=api_handle_exception_
+        handler=handle_exception
     )
-    fastapi_app.add_exception_handler(
+    app.add_exception_handler(
         exc_class_or_status_code=ValueError,
-        handler=api_handle_exception_
+        handler=handle_exception
     )
-    fastapi_app.add_exception_handler(
+    app.add_exception_handler(
         exc_class_or_status_code=fastapi.exceptions.RequestValidationError,
-        handler=api_handle_exception_
+        handler=handle_exception
     )
-    fastapi_app.add_exception_handler(
+    app.add_exception_handler(
         exc_class_or_status_code=starlette.exceptions.HTTPException,
-        handler=api_handle_exception_
-    )
-    return fastapi_app
-
-
-def add_middleware_cors_to_fastapi_app(*, fastapi_app: FastAPI) -> FastAPI:
-    fastapi_app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    return fastapi_app
-
-
-def add_ar_fastapi_static_to_fastapi_app(*, fastapi_app: FastAPI):
-    ar_fastapi_static_dirpath = os.path.join(str(pathlib.Path(__file__).parent), "ar_fastapi_static")
-    fastapi_app.mount(
-        "/ar_fastapi_static",
-        StaticFiles(directory=ar_fastapi_static_dirpath),
-        name="ar_fastapi_static"
+        handler=handle_exception
     )
+    return app
 
 
-def add_ar_fastapi_static_docs_and_redoc_handlers_to_fastapi_app(
+def add_swagger_to_app(
         *,
-        fastapi_app: FastAPI,
+        app: FastAPI,
         favicon_url: str | None = None
 ):
-    add_ar_fastapi_static_to_fastapi_app(fastapi_app=fastapi_app)
+    app.mount(
+        "/ar_fastapi_static",
+        StaticFiles(directory=os.path.join(str(pathlib.Path(__file__).parent), "ar_fastapi_static")),
+        name="ar_fastapi_static"
+    )
 
-    @fastapi_app.get("/docs", include_in_schema=False)
+    @app.get("/docs", include_in_schema=False)
     async def custom_swagger_ui_html():
         return get_swagger_ui_html(
-            openapi_url=fastapi_app.openapi_url,
-            title=fastapi_app.title,
+            openapi_url=app.openapi_url,
+            title=app.title,
             swagger_js_url="/ar_fastapi_static/swagger-ui/swagger-ui-bundle.js",
             swagger_css_url="/ar_fastapi_static/swagger-ui/swagger-ui.css",
             swagger_favicon_url=favicon_url
         )
 
-    @fastapi_app.get("/redoc", include_in_schema=False)
+    @app.get("/redoc", include_in_schema=False)
     async def custom_redoc_html():
         return get_redoc_html(
-            openapi_url=fastapi_app.openapi_url,
-            title=fastapi_app.title,
+            openapi_url=app.openapi_url,
+            title=app.title,
             redoc_js_url="/ar_fastapi_static/redoc/redoc.standalone.js",
             redoc_favicon_url=favicon_url
         )
 
-    return fastapi_app
+    return app
+
+
+def add_cors_to_app(*, app: FastAPI):
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+    return app
+
+
+def add_needed_api_router_to_app(*, app: FastAPI):
+    api_router = APIRouter()
+
+    @api_router.get(
+        "/healthcheck",
+        response_model=ErrorSO,
+        status_code=starlette.status.HTTP_200_OK,
+        tags=["Healthcheck"]
+    )
+    async def _():
+        return APIJSONResponse(
+            status_code=starlette.status.HTTP_200_OK,
+            content=RawDataSO(data={"healthcheck": "healthcheck"})
+        )
+
+    @api_router.get(
+        "/arpakitlib",
+        response_model=ErrorSO,
+        status_code=starlette.status.HTTP_200_OK,
+        tags=["arpakitlib"]
+    )
+    async def _():
+        return APIJSONResponse(
+            status_code=starlette.status.HTTP_200_OK,
+            content=RawDataSO(data={"arpakitlib": "arpakitlib"})
+        )
 
+    app.include_router(router=api_router, prefix="")
 
-class BaseAPIStartupEvent:
+    return app
+
+
+class BaseStartupAPIEvent:
     def __init__(self, *args, **kwargs):
         self._logger = logging.getLogger(self.__class__.__name__)
 
@@ -255,7 +381,38 @@ class BaseAPIStartupEvent:
         self._logger.info("on_startup ends")
 
 
-class BaseAPIShutdownEvent:
+class InitSqlalchemyDBStartupAPIEvent(BaseStartupAPIEvent):
+    def __init__(self, sqlalchemy_db: SQLAlchemyDB):
+        super().__init__()
+        self.sqlalchemy_db = sqlalchemy_db
+
+    def async_on_startup(self, *args, **kwargs):
+        self.sqlalchemy_db.init()
+
+
+class SyncSafeRunExecuteOperationWorkerStartupAPIEvent(BaseStartupAPIEvent):
+    def __init__(self, execute_operation_worker: ExecuteOperationWorker):
+        super().__init__()
+        self.execute_operation_worker = execute_operation_worker
+
+    def async_on_startup(self, *args, **kwargs):
+        thread = threading.Thread(
+            target=self.execute_operation_worker.sync_safe_run,
+            daemon=True
+        )
+        thread.start()
+
+
+class AsyncSafeRunExecuteOperationWorkerStartupAPIEvent(BaseStartupAPIEvent):
+    def __init__(self, execute_operation_worker: ExecuteOperationWorker):
+        super().__init__()
+        self.execute_operation_worker = execute_operation_worker
+
+    def async_on_startup(self, *args, **kwargs):
+        _ = asyncio.create_task(self.execute_operation_worker.async_safe_run())
+
+
+class BaseShutdownAPIEvent:
     def __init__(self, *args, **kwargs):
         self._logger = logging.getLogger(self.__class__.__name__)
 
@@ -264,28 +421,70 @@ class BaseAPIShutdownEvent:
         self._logger.info("on_shutdown ends")
 
 
-class APIStartupEventInitEasySQLAlchemyDB(BaseAPIStartupEvent):
-    def __init__(self, easy_sqlalchemy_db: EasySQLAlchemyDB):
-        super().__init__()
-        self.easy_sqlalchemy_db = easy_sqlalchemy_db
+class BaseTransmittedAPIData(BaseModel):
+    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
-    async def async_on_startup(self, *args, **kwargs):
-        self.easy_sqlalchemy_db.init()
+
+def get_transmitted_api_data(request: starlette.requests.Request) -> BaseTransmittedAPIData:
+    return request.app.state.transmitted_api_data
+
+
+def simple_api_router_for_testing():
+    router = APIRouter(tags=["Testing"])
+
+    @router.get(
+        "/raise_fake_exception_1",
+        response_model=ErrorSO
+    )
+    async def _():
+        raise fastapi.HTTPException(status_code=starlette.status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+    @router.get(
+        "/raise_fake_exception_2",
+        response_model=ErrorSO
+    )
+    async def _():
+        raise APIException(
+            error_code="raise_fake_exception_2",
+            error_code_specification="raise_fake_exception_2",
+            error_description="raise_fake_exception_2"
+        )
+
+    @router.get(
+        "/raise_fake_exception_3",
+        response_model=ErrorSO
+    )
+    async def _():
+        raise Exception("raise_fake_exception_3")
+
+    @router.get(
+        "/check_params",
+        response_model=ErrorSO
+    )
+    async def _(name: int = Query()):
+        return RawDataSO(data={"name": name})
+
+    return router
 
 
 def create_fastapi_app(
         *,
         title: str = "ARPAKITLIB FastAPI",
-        description: str | None = None,
-        api_startup_events: list[BaseAPIStartupEvent] | None = None,
-        api_shutdown_events: list[BaseAPIStartupEvent] | None = None,
-        api_handle_exception_: Callable | None = simple_api_handle_exception
+        description: str | None = "ARPAKITLIB FastAPI",
+        log_filepath: str | None = "./story.log",
+        handle_exception_: Callable | None = create_handle_exception(),
+        startup_api_events: list[BaseStartupAPIEvent] | None = None,
+        shutdown_api_events: list[BaseStartupAPIEvent] | None = None,
+        transmitted_api_data: BaseTransmittedAPIData = BaseTransmittedAPIData(),
+        api_router: APIRouter = simple_api_router_for_testing()
 ):
-    if api_startup_events is None:
-        api_startup_events = [BaseAPIStartupEvent()]
+    setup_normal_logging(log_filepath=log_filepath)
+
+    if not startup_api_events:
+        startup_api_events = [BaseStartupAPIEvent()]
 
-    if api_shutdown_events is None:
-        api_shutdown_events = [BaseAPIShutdownEvent()]
+    if not shutdown_api_events:
+        shutdown_api_events = [BaseShutdownAPIEvent()]
 
     app = FastAPI(
         title=title,
@@ -293,25 +492,31 @@ def create_fastapi_app(
         docs_url=None,
         redoc_url=None,
         openapi_url="/openapi",
-        on_startup=[api_startup_event.async_on_startup for api_startup_event in api_startup_events],
-        on_shutdown=[api_shutdown_event.async_on_shutdown for api_shutdown_event in api_shutdown_events]
+        on_startup=[api_startup_event.async_on_startup for api_startup_event in startup_api_events],
+        on_shutdown=[api_shutdown_event.async_on_shutdown for api_shutdown_event in shutdown_api_events]
     )
 
-    add_middleware_cors_to_fastapi_app(fastapi_app=app)
+    app.state.transmitted_api_data = transmitted_api_data
 
-    add_ar_fastapi_static_docs_and_redoc_handlers_to_fastapi_app(fastapi_app=app)
+    add_cors_to_app(app=app)
 
-    if api_handle_exception_:
-        add_exception_handler_to_fastapi_app(
-            fastapi_app=app,
-            api_handle_exception_=api_handle_exception_
+    add_swagger_to_app(app=app)
+
+    if handle_exception_:
+        add_exception_handler_to_app(
+            app=app,
+            handle_exception=handle_exception_
         )
     else:
-        add_exception_handler_to_fastapi_app(
-            fastapi_app=app,
-            api_handle_exception_=simple_api_handle_exception
+        add_exception_handler_to_app(
+            app=app,
+            handle_exception=create_handle_exception()
         )
 
+    add_needed_api_router_to_app(app=app)
+
+    app.include_router(router=api_router)
+
     return app
 
 

arpakitlib/ar_need_type_util.py

@@ -3,12 +3,12 @@
 import json
 from typing import Any
 
-from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_enumeration_util import Enumeration
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-class NeedTypes(EasyEnumeration):
+class NeedTypes(Enumeration):
     str_ = "str"
     int_ = "int"
     bool_ = "bool"

arpakitlib/ar_openai_util.py

@@ -13,7 +13,7 @@ https://platform.openai.com/docs/
 """
 
 
-class EasyOpenAI:
+class OpenAIAPIClient:
     def __init__(
             self,
             *,

arpakitlib/{ar_operation_util.py → ar_operation_execution_util.py}

@@ -4,100 +4,29 @@ from __future__ import annotations
 
 import logging
 import traceback
-from datetime import datetime, timedelta
+from datetime import timedelta
 from typing import Any
 
-from sqlalchemy import TIMESTAMP, TEXT, asc
-from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import Mapped, mapped_column, Session
+from sqlalchemy import asc
+from sqlalchemy.orm import Session
 
 from arpakitlib.ar_base_worker import BaseWorker
 from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_dict_util import combine_dicts
-from arpakitlib.ar_easy_sqlalchemy_util import EasySQLAlchemyDB
-from arpakitlib.ar_enumeration import EasyEnumeration
-from arpakitlib.ar_fastapi_util import BaseAPISimpleSO
-from arpakitlib.ar_sqlalchemy_model_util import SimpleDBM
-from arpakitlib.ar_story_log_util import StoryLogDBM
+from arpakitlib.ar_sqlalchemy_model_util import OperationDBM, StoryLogDBM
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 _logger = logging.getLogger(__name__)
 
 
-class OperationDBM(SimpleDBM):
-    __tablename__ = "operation"
-
-    class Statuses(EasyEnumeration):
-        waiting_for_execution = "waiting_for_execution"
-        executing = "executing"
-        executed_without_error = "executed_without_error"
-        executed_with_error = "executed_with_error"
-
-    class Types(EasyEnumeration):
-        healthcheck_ = "healthcheck"
-        raise_fake_exception = "raise_fake_exception"
-
-    status: Mapped[str] = mapped_column(
-        TEXT, index=True, insert_default=Statuses.waiting_for_execution,
-        server_default=Statuses.waiting_for_execution, nullable=False
-    )
-    type: Mapped[str] = mapped_column(
-        TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
-    )
-    execution_start_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
-    execution_finish_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
-    input_data: Mapped[dict[str, Any]] = mapped_column(
-        JSONB,
-        insert_default={},
-        server_default="{}",
-        nullable=False
-    )
-    output_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
-    error_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
-
-    def raise_if_executed_with_error(self):
-        if self.status == self.Statuses.executed_with_error:
-            raise Exception(
-                f"Operation (id={self.id}, type={self.type}) executed with error, error_data={self.error_data}"
-            )
-
-    def raise_if_error_data(self):
-        if self.status == self.Statuses.executed_with_error:
-            raise Exception(
-                f"Operation (id={self.id}, type={self.type}) has error_data, error_data={self.error_data}"
-            )
-
-    @property
-    def duration(self) -> timedelta | None:
-        if self.execution_start_dt is None or self.execution_finish_dt is None:
-            return None
-        return self.execution_finish_dt - self.execution_start_dt
-
-    @property
-    def duration_total_seconds(self) -> float | None:
-        if self.duration is None:
-            return None
-        return self.duration.total_seconds()
-
-
-class OperationSO(BaseAPISimpleSO):
-    execution_start_dt: datetime | None
-    execution_finish_dt: datetime | None
-    status: str
-    type: str
-    input_data: dict[str, Any]
-    output_data: dict[str, Any]
-    error_data: dict[str, Any]
-    duration_total_seconds: float | None
-
-
 def get_operation_for_execution(
         *,
-        easy_sql_alchemy_db: EasySQLAlchemyDB,
+        sqlalchemy_db: SQLAlchemyDB,
         filter_operation_type: str | None = None
 ) -> OperationDBM | None:
-    with easy_sql_alchemy_db.new_session() as session:
+    with sqlalchemy_db.new_session() as session:
         query = (
             session
             .query(OperationDBM)
@@ -114,32 +43,30 @@ def get_operation_by_id(
         *,
         session: Session,
         filter_operation_id: int,
-        strict: bool = False
+        raise_if_not_found: bool = False
 ) -> OperationDBM | None:
     query = (
         session
         .query(OperationDBM)
         .filter(OperationDBM.id == filter_operation_id)
     )
-    if strict:
+    if raise_if_not_found:
         return query.one()
     else:
         return query.one_or_none()
 
 
 class BaseOperationExecutor:
-    def __init__(self, *, easy_sql_alchemy_db: EasySQLAlchemyDB):
+    def __init__(self, *, sqlalchemy_db: SQLAlchemyDB):
         self._logger = logging.getLogger(self.__class__.__name__)
-        self.easy_sql_alchemy_db = easy_sql_alchemy_db
+        self.sql_alchemy_db = sqlalchemy_db
 
     async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         if operation_dbm.type == OperationDBM.Types.healthcheck_:
             self._logger.info("healthcheck")
-        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception:
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
-        else:
-            raise ValueError(f"unknown operation.type = {operation_dbm.type}")
         return operation_dbm
 
     async def async_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
@@ -149,9 +76,9 @@ class BaseOperationExecutor:
             f", operation_dbm.type={operation_dbm.type}"
         )
 
-        with self.easy_sql_alchemy_db.new_session() as session:
+        with self.sql_alchemy_db.new_session() as session:
             operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, strict=True
+                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
             )
             operation_dbm.execution_start_dt = now_utc_dt()
             operation_dbm.status = OperationDBM.Statuses.executing
@@ -168,9 +95,10 @@ class BaseOperationExecutor:
             exception = exception_
             traceback_str = traceback.format_exc()
 
-        with self.easy_sql_alchemy_db.new_session() as session:
+        with self.sql_alchemy_db.new_session() as session:
+
             operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, strict=True
+                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
             )
             operation_dbm.execution_finish_dt = now_utc_dt()
             if exception:
@@ -182,7 +110,21 @@ class BaseOperationExecutor:
             else:
                 operation_dbm.status = OperationDBM.Statuses.executed_without_error
             session.commit()
+
+            story_log_dbm = StoryLogDBM(
+                level=StoryLogDBM.Levels.error,
+                title="Error in async_execute_operation",
+                data={
+                    "operation_id": operation_dbm.id,
+                    "exception_str": str(exception),
+                    "traceback_str": traceback_str
+                }
+            )
+            session.add(story_log_dbm)
+            session.commit()
+
             session.refresh(operation_dbm)
+            session.refresh(story_log_dbm)
 
         self._logger.info(
             f"finish async_safe_execute_operation"
@@ -195,11 +137,9 @@ class BaseOperationExecutor:
     def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         if operation_dbm.type == OperationDBM.Types.healthcheck_:
             self._logger.info("healthcheck")
-        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception:
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
-        else:
-            raise ValueError(f"unknown operation.type = {operation_dbm.type}")
         return operation_dbm
 
     def sync_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
@@ -209,9 +149,9 @@ class BaseOperationExecutor:
             f", operation_dbm.type={operation_dbm.type}"
         )
 
-        with self.easy_sql_alchemy_db.new_session() as session:
+        with self.sql_alchemy_db.new_session() as session:
             operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, strict=True
+                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
             )
             operation_dbm.execution_start_dt = now_utc_dt()
             operation_dbm.status = OperationDBM.Statuses.executing
@@ -228,10 +168,10 @@ class BaseOperationExecutor:
             exception = exception_
             traceback_str = traceback.format_exc()
 
-        with self.easy_sql_alchemy_db.new_session() as session:
+        with self.sql_alchemy_db.new_session() as session:
 
             operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, strict=True
+                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
             )
             operation_dbm.execution_finish_dt = now_utc_dt()
             if exception:
@@ -249,7 +189,7 @@ class BaseOperationExecutor:
                 title="Error in sync_execute_operation",
                 data={
                     "operation_id": operation_dbm.id,
-                    "exception": str(exception),
+                    "exception_str": str(exception),
                     "traceback_str": traceback_str
                 }
             )
@@ -274,27 +214,29 @@ class ExecuteOperationWorker(BaseWorker):
     def __init__(
             self,
             *,
-            easy_sql_alchemy_db: EasySQLAlchemyDB,
-            operation_executor: BaseOperationExecutor,
-            need_operation_type: str | None = None
+            sqlalchemy_db: SQLAlchemyDB,
+            operation_executor: BaseOperationExecutor | None = None,
+            filter_operation_type: str | None = None
     ):
         super().__init__()
-        self.easy_sql_alchemy_db = easy_sql_alchemy_db
+        self.sqlalchemy_db = sqlalchemy_db
         self.timeout_after_run = timedelta(seconds=0.1).total_seconds()
         self.timeout_after_err_in_run = timedelta(seconds=1).total_seconds()
+        if operation_executor is None:
+            operation_executor = BaseOperationExecutor(sqlalchemy_db=sqlalchemy_db)
         self.operation_executor = operation_executor
-        self.need_operation_type = need_operation_type
+        self.filter_operation_type = filter_operation_type
 
     async def async_on_startup(self):
-        self.easy_sql_alchemy_db.init()
+        self.sqlalchemy_db.init()
 
     async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         return await self.operation_executor.async_safe_execute_operation(operation_dbm=operation_dbm)
 
     async def async_run(self):
         operation_dbm: OperationDBM | None = get_operation_for_execution(
-            easy_sql_alchemy_db=self.easy_sql_alchemy_db,
-            filter_operation_type=self.need_operation_type
+            sqlalchemy_db=self.sqlalchemy_db,
+            filter_operation_type=self.filter_operation_type
         )
 
         if not operation_dbm:
@@ -306,15 +248,15 @@ class ExecuteOperationWorker(BaseWorker):
         self._logger.exception(exception)
 
     def sync_on_startup(self):
-        self.easy_sql_alchemy_db.init()
+        self.sqlalchemy_db.init()
 
     def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         return self.operation_executor.sync_safe_execute_operation(operation_dbm=operation_dbm)
 
     def sync_run(self):
         operation_dbm: OperationDBM | None = get_operation_for_execution(
-            easy_sql_alchemy_db=self.easy_sql_alchemy_db,
-            filter_operation_type=self.need_operation_type
+            sqlalchemy_db=self.sqlalchemy_db,
+            filter_operation_type=self.filter_operation_type
         )
 
         if not operation_dbm:
@@ -324,7 +266,3 @@ class ExecuteOperationWorker(BaseWorker):
 
     def sync_run_on_error(self, exception: BaseException, kwargs: dict[str, Any]):
         self._logger.exception(exception)
-
-
-def import_ar_operation_execution_util():
-    _logger.info("import_ar_operation_execution_util")

arpakitlib/ar_sqlalchemy_model_util.py

@@ -1,13 +1,15 @@
 # arpakit
 
-from datetime import datetime
+from datetime import datetime, timedelta
 from typing import Any
 from uuid import uuid4
 
 from sqlalchemy import inspect, INTEGER, TEXT, TIMESTAMP
+from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_enumeration_util import Enumeration
 from arpakitlib.ar_json_util import safely_transfer_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -45,3 +47,76 @@ class SimpleDBM(BaseDBM):
 
     def __repr__(self):
         return f"{self.__class__.__name__.removesuffix('DBM')} (id={self.id})"
+
+
+class StoryLogDBM(SimpleDBM):
+    __tablename__ = "story_log"
+
+    class Levels(Enumeration):
+        info = "info"
+        warning = "warning"
+        error = "error"
+
+    level: Mapped[str] = mapped_column(
+        TEXT, insert_default=Levels.info, server_default=Levels.info, index=True, nullable=False
+    )
+    title: Mapped[str | None] = mapped_column(TEXT, index=True, default=None, nullable=True)
+    data: Mapped[dict[str, Any]] = mapped_column(
+        JSONB, insert_default={}, server_default="{}", index=True, nullable=False
+    )
+
+
+class OperationDBM(SimpleDBM):
+    __tablename__ = "operation"
+
+    class Statuses(Enumeration):
+        waiting_for_execution = "waiting_for_execution"
+        executing = "executing"
+        executed_without_error = "executed_without_error"
+        executed_with_error = "executed_with_error"
+
+    class Types(Enumeration):
+        healthcheck_ = "healthcheck"
+        raise_fake_exception_ = "raise_fake_exception"
+
+    status: Mapped[str] = mapped_column(
+        TEXT, index=True, insert_default=Statuses.waiting_for_execution,
+        server_default=Statuses.waiting_for_execution, nullable=False
+    )
+    type: Mapped[str] = mapped_column(
+        TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
+    )
+    execution_start_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
+    execution_finish_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
+    input_data: Mapped[dict[str, Any]] = mapped_column(
+        JSONB,
+        insert_default={},
+        server_default="{}",
+        nullable=False
+    )
+    output_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
+    error_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
+
+    def raise_if_executed_with_error(self):
+        if self.status == self.Statuses.executed_with_error:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) executed with error, error_data={self.error_data}"
+            )
+
+    def raise_if_error_data(self):
+        if self.error_data:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) has error_data, error_data={self.error_data}"
+            )
+
+    @property
+    def duration(self) -> timedelta | None:
+        if self.execution_start_dt is None or self.execution_finish_dt is None:
+            return None
+        return self.execution_finish_dt - self.execution_start_dt
+
+    @property
+    def duration_total_seconds(self) -> float | None:
+        if self.duration is None:
+            return None
+        return self.duration.total_seconds()

arpakitlib/{ar_easy_sqlalchemy_util.py → ar_sqlalchemy_util.py}

@@ -12,11 +12,11 @@ from sqlalchemy.orm.session import Session
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-class EasySQLAlchemyDB:
+class SQLAlchemyDB:
     def __init__(
             self,
             *,
-            db_url: str,
+            db_url: str = "postgresql://arpakitlib:arpakitlib@localhost:50629/arpakitlib",
             echo: bool = False,
             need_include_operation_dbm: bool = False,
             need_include_story_dbm: bool = False
@@ -37,16 +37,6 @@ class EasySQLAlchemyDB:
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.func_new_session_counter = 0
 
-    def include_operation_dbm(self):
-        if self.need_include_operation_dbm:
-            from arpakitlib.ar_operation_util import import_ar_operation_execution_util
-            import_ar_operation_execution_util()
-
-    def include_story_dbm(self):
-        if self.need_include_story_dbm or self.need_include_operation_dbm:
-            from arpakitlib.ar_story_log_util import import_ar_story_util
-            import_ar_story_util()
-
     def drop_celery_tables(self):
         with self.engine.connect() as connection:
             connection.execute(text("DROP TABLE IF EXISTS celery_tasksetmeta CASCADE;"))
@@ -62,8 +52,6 @@ class EasySQLAlchemyDB:
             self._logger.info("celery tables data were removed")
 
     def init(self):
-        self.include_operation_dbm()
-        self.include_story_dbm()
         from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
         BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)
         self._logger.info("db was inited")
@@ -74,8 +62,6 @@ class EasySQLAlchemyDB:
         self._logger.info("db was dropped")
 
     def reinit(self):
-        self.include_operation_dbm()
-        self.include_story_dbm()
         from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
         BaseDBM.metadata.drop_all(bind=self.engine, checkfirst=True)
         BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)

arpakitlib/ar_type_util.py

@@ -1,13 +1,10 @@
 # arpakit
-
+import inspect
 from typing import Optional, Any
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
-# ---
-
-
 class NotSet:
     pass
 
@@ -44,9 +41,6 @@ def make_none_if_not_set(v: Any) -> Any:
     return v
 
 
-# ---
-
-
 def raise_for_type(comparable, need_type, comment_for_error: Optional[str] = None):
     if comparable is need_type:
         return
@@ -73,7 +67,9 @@ def raise_for_types(comparable, need_types, comment_for_error: Optional[str] = N
         raise TypeError(err)
 
 
-# ---
+def raise_if_not_async_func(func: Any):
+    if not inspect.iscoroutinefunction(func):
+        raise TypeError(f"The provided function '{func.__name__}' is not an async function")
 
 
 def __example():

arpakitlib/ar_yookassa_api_client.py

@@ -12,7 +12,7 @@ import aiohttp
 import requests
 
 from arpakitlib.ar_dict_util import combine_dicts
-from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_enumeration_util import Enumeration
 from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 from arpakitlib.ar_type_util import raise_for_type
 
@@ -23,7 +23,7 @@ https://yookassa.ru/developers/api
 """
 
 
-class YookassaPaymentStatuses(EasyEnumeration):
+class YookassaPaymentStatuses(Enumeration):
     pending = "pending"
     waiting_for_capture = "waiting_for_capture"
     succeeded = "succeeded"

{arpakitlib-1.5.34.dist-info → arpakitlib-1.5.37.dist-info}/METADATA

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

{arpakitlib-1.5.34.dist-info → arpakitlib-1.5.37.dist-info}/RECORD

@@ -6,7 +6,7 @@ arpakitlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arpakitlib/ar_additional_model_util.py,sha256=Eq7pvVUgO2L3gYBocm-pP9TrztTb8VNCp7LdRMml-F8,237
 arpakitlib/ar_aiogram_util.py,sha256=IA48PRMIJrPLMhFA0Eb2vQpLcqm98o9tKfC3pDy8qsI,12022
 arpakitlib/ar_arpakit_lib_module_util.py,sha256=YzobxRG8-QJ1L5r_8wBdL668CwXoQRIM1Cpec1o2WBc,5447
-arpakitlib/ar_arpakit_schedule_uust_api_client.py,sha256=V8n5XxkrsZo7ASNAepD0mqgRtI7qIleCDgk7WAmdLW8,18244
+arpakitlib/ar_arpakit_schedule_uust_api_client.py,sha256=SYWWQDohPnw0qpBIu2hEvGZRVdaI4NUUQdEjnMnseo4,18237
 arpakitlib/ar_arpakitlib_info.py,sha256=cvgrLnEznmYkCAg1adbY46ATjD6GJd-Yk8PTgOPjpKM,248
 arpakitlib/ar_base64_util.py,sha256=aZkg2cZTuAaP2IWeG_LXJ6RO7qhyskVwec-Lks0iM-k,676
 arpakitlib/ar_base_worker.py,sha256=Y6yRFp1nhhTyv-TeGDao-3q4ICVVJ2zVsKdIlHdiGSI,2897
@@ -14,9 +14,8 @@ arpakitlib/ar_cache_file.py,sha256=m73_vU6bMjXsIurSPO9VCLcHsiHk8ITFS0LNjfI_8Uw,3
 arpakitlib/ar_datetime_util.py,sha256=Xe1NiT9oPQzNSG7RVRkhukhbg4i-hhS5ImmV7sPUc8o,971
 arpakitlib/ar_dict_util.py,sha256=cF5LQJ6tLqyGoEXfDljMDZrikeZoWPw7CgINHIFGvXM,419
 arpakitlib/ar_dream_ai_api_client.py,sha256=hDPL9wbG4MjIuhn2ed6qepueogANIkt-NddhhiPUv0Y,4029
-arpakitlib/ar_easy_sqlalchemy_util.py,sha256=tHVL5bimXzY7u7TXEH--W7LSebSpN0Y5WN3iWiD8OR8,4180
 arpakitlib/ar_encrypt_and_decrypt_util.py,sha256=GhWnp7HHkbhwFVVCzO1H07m-5gryr4yjWsXjOaNQm1Y,520
-arpakitlib/ar_enumeration.py,sha256=6KUJYOabHDPLfdigBVN0ZI4ZOUJh8TkL0g4o92Hke2I,2254
+arpakitlib/ar_enumeration_util.py,sha256=0DN46uyI0Gu9JPDgso3XPbnre7hZZefYTZwmmE1iYH4,2250
 arpakitlib/ar_fastapi_static/redoc/redoc.standalone.js,sha256=WCuodUNv1qVh0oW5fjnJDwb5AwOue73jKHdI9z8iGKU,909365
 arpakitlib/ar_fastapi_static/swagger-ui/favicon-16x16.png,sha256=ryStYE3Xs7zaj5dauXMHX0ovcKQIeUShL474tjo-B8I,665
 arpakitlib/ar_fastapi_static/swagger-ui/favicon-32x32.png,sha256=PtYS9B4FDKXnAAytbxy-fn2jn2X8qZwC6Z5lkQVuWDc,628
@@ -36,7 +35,7 @@ arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.css,sha256=jzPZlgJTFwSdSphk9C
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.css.map,sha256=5wq8eXMLU6Zxb45orZPL1zAsBFJReFw6GjYqGpUX3hg,262650
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.js,sha256=ffrLZHHEQ_g84A-ul3yWa10Kk09waOAxHcQXPuZuavg,339292
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.js.map,sha256=9UhIW7MqCOZPAz1Sl1IKfZUuhWU0p-LJqrnjjJD9Xhc,1159454
-arpakitlib/ar_fastapi_util.py,sha256=zuq3bGhCvnGtD3_Axh4vE_Y_-JNg_W_wEBa9gHO9CXY,10718
+arpakitlib/ar_fastapi_util.py,sha256=7YUx9WL4hc_TAiNjFDqxdcpAutvv0UtI5IEICbBZdVQ,16847
 arpakitlib/ar_file_storage_in_dir.py,sha256=D3e3rGuHoI6xqAA5mVvEpVVpOWY1jyjNsjj2UhyHRbE,3674
 arpakitlib/ar_generate_env_example.py,sha256=WseNlk_So6mTVQ2amMuigWYV4ZVmd940POvXtodoYj0,325
 arpakitlib/ar_hash_util.py,sha256=Iqy6KBAOLBQMFLWv676boI5sV7atT2B-fb7aCdHOmIQ,340
@@ -49,23 +48,23 @@ arpakitlib/ar_list_of_dicts_to_xlsx.py,sha256=MyjEl4Jl4beLVZqLVQMMv0-XDtBD3Xh4Z_
 arpakitlib/ar_list_util.py,sha256=2woOAHAU8oTIiVjZ8GLnx15odEaoQUq3Q0JPxlufFF0,457
 arpakitlib/ar_logging_util.py,sha256=c5wX2FLqCzb4aLckLVhIJ7go52rJQ4GN9dIkJ6KMc3o,1500
 arpakitlib/ar_mongodb_util.py,sha256=2ECkTnGAZ92qxioL-fmN6R4yZOSr3bXdXLWTzT1C3vk,4038
-arpakitlib/ar_need_type_util.py,sha256=qCRSWlSgx-3yU0NRHZDQ5lCOmuZKcz2Na3py9nr6hJM,1618
-arpakitlib/ar_openai_util.py,sha256=d5Aj1O2yo_zYLZCLeOLvuveYYxA2jGOqhMs1oUbuVk8,1210
-arpakitlib/ar_operation_util.py,sha256=miBG6hywKRwFaeE0tUHotAw7MBylRBlXL6YQnBCnfOU,12419
+arpakitlib/ar_need_type_util.py,sha256=n2kBETxzOSVhSVoy7qUtHtuQzgrrxzgi1_iVQimPb9o,1615
+arpakitlib/ar_openai_util.py,sha256=dHUbfg1sVVCjsNl_fra3iCMEz1bR-Hk9fE-DdYbu7Wc,1215
+arpakitlib/ar_operation_execution_util.py,sha256=Vxuu6MoYsmR2GS5UlW_fIDwNf62Gsw0UtjeSnh4Evi8,9928
 arpakitlib/ar_parse_command.py,sha256=qpr2OwG3Bf7DFiL9S3iWgtbvtE80RSC35E5zFJvjG1I,2714
 arpakitlib/ar_postgresql_util.py,sha256=SAHEmAyMkZe516uk2gS830v_Wn2kRUZUYNcTNwmgXJk,1160
 arpakitlib/ar_run_cmd.py,sha256=D_rPavKMmWkQtwvZFz-Io5Ak8eSODHkcFeLPzNVC68g,1072
 arpakitlib/ar_schedule_uust_api_client.py,sha256=1JGUy6rrjAXdWjeAqiAOQlCAEV3xuc5FUDWfXODKB-A,5770
 arpakitlib/ar_sleep_util.py,sha256=9ZN4Qo4eZ_q3hjM7vNBQjFRcH-9-sqv3QLSjnxVJE90,1405
-arpakitlib/ar_sqlalchemy_model_util.py,sha256=3zscvaloi9XY1NR70rJ4-jJlFUIqhmTbQ9wdvK-Yjf8,1379
-arpakitlib/ar_ssh_runner.py,sha256=jlnss4V4pziBN1rBzoK_lDiWm6nMOqGXfa6NFJSKH-Y,6796
-arpakitlib/ar_story_log_util.py,sha256=RmrjsWHpFvNYPcj6Htplzc6lMnw-f9t_RSIsqyskXeg,1141
+arpakitlib/ar_sqlalchemy_model_util.py,sha256=tKz6n9zuebo2J9yTr6IQUHoXZ9KF340MAo4UiDXaX_4,4251
+arpakitlib/ar_sqlalchemy_util.py,sha256=VH23Xld3k5wITkwR0JcaBkO77gmxWn9jlK4eyxKuz_0,3665
+arpakitlib/ar_ssh_util.py,sha256=jlnss4V4pziBN1rBzoK_lDiWm6nMOqGXfa6NFJSKH-Y,6796
 arpakitlib/ar_str_util.py,sha256=xSEzmsDvRiZVaxyqFFjcgzpphktCbXg2FHcvsd1DYpA,1885
-arpakitlib/ar_type_util.py,sha256=-h-SCsVl11eVo1u4hy2Asn0IfD5TIxmX3Ndug4AvnPE,1761
-arpakitlib/ar_yookassa_api_client.py,sha256=BwsTygaXf35AACVBl_09uYlSD_t-U1OOzbj58OOFT4Q,6480
+arpakitlib/ar_type_util.py,sha256=I6jbTz7_dxR1lkhz1JfUb5ZyLLdXVhG_-hzjdgT6N6s,1932
+arpakitlib/ar_yookassa_api_client.py,sha256=WZoTd10d2lOmT0lCdlQFTB0LEVARubqLEiFtPNQLvi8,6477
 arpakitlib/ar_zabbix_util.py,sha256=MTQbmS0QpNCKNOGONNQHf6j7KTZsKGlIbd5rCH0R0WI,6313
-arpakitlib-1.5.34.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
-arpakitlib-1.5.34.dist-info/METADATA,sha256=zPM7OWINm8HMIVCv2TT4eA9jyZI-enIAaXSjTsiR-Vg,2330
-arpakitlib-1.5.34.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
-arpakitlib-1.5.34.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-arpakitlib-1.5.34.dist-info/RECORD,,
+arpakitlib-1.5.37.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
+arpakitlib-1.5.37.dist-info/METADATA,sha256=mYUQJqE6gMICk_29Mn7VcJJcqQtkQMm-DhGce-Dd4YU,2330
+arpakitlib-1.5.37.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
+arpakitlib-1.5.37.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+arpakitlib-1.5.37.dist-info/RECORD,,

arpakitlib/ar_story_log_util.py

@@ -1,40 +0,0 @@
-import logging
-from typing import Any
-
-from sqlalchemy import TEXT
-from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.orm import Mapped, mapped_column
-
-from arpakitlib.ar_enumeration import EasyEnumeration
-from arpakitlib.ar_fastapi_util import BaseAPISimpleSO
-from arpakitlib.ar_sqlalchemy_model_util import SimpleDBM
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-_logger = logging.getLogger(__name__)
-
-
-class StoryLogDBM(SimpleDBM):
-    __tablename__ = "story_log"
-
-    class Levels(EasyEnumeration):
-        info = "info"
-        warning = "warning"
-        error = "error"
-
-    level: Mapped[str] = mapped_column(
-        TEXT, insert_default=Levels.info, server_default=Levels.info, index=True, nullable=False
-    )
-    title: Mapped[str | None] = mapped_column(TEXT, index=True, default=None, nullable=True)
-    data: Mapped[dict[str, Any]] = mapped_column(
-        JSONB, insert_default={}, server_default="{}", index=True, nullable=False
-    )
-
-
-class StoryLogSO(BaseAPISimpleSO):
-    level: str
-    title: str | None
-    data: dict[str, Any]
-
-
-def import_ar_story_util():
-    _logger.info("import_ar_operation_execution_util")