arpakitlib 1.6.47__py3-none-any.whl → 1.7.90__py3-none-any.whl

arpakitlib/ar_fastapi_util.py

@@ -6,8 +6,8 @@ import asyncio
 import logging
 import os.path
 import pathlib
-import threading
 import traceback
+from contextlib import suppress
 from datetime import datetime
 from typing import Any, Callable
 
@@ -17,24 +17,24 @@ import fastapi.security
 import starlette.exceptions
 import starlette.requests
 import starlette.status
-from fastapi import FastAPI, APIRouter, Query, Security
+from fastapi import FastAPI, APIRouter, Query, Security, Depends
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
 from fastapi.security import APIKeyHeader
-from jaraco.context import suppress
 from pydantic import BaseModel, ConfigDict
+from starlette import status
 from starlette.middleware.cors import CORSMiddleware
 from starlette.staticfiles import StaticFiles
 
-from arpakitlib.ar_base_worker_util import BaseWorker
+from arpakitlib.ar_base_worker_util import BaseWorker, safe_run_worker_in_background, SafeRunInBackgroundModes
 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_file_storage_in_dir_util import FileStorageInDir
+from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_function, is_async_object
+from arpakitlib.ar_json_util import safely_transfer_obj_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_settings_util import SimpleSettings
-from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM
+from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM, OperationDBM
 from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
-from arpakitlib.ar_type_util import raise_for_type, raise_if_not_async_func
+from arpakitlib.ar_type_util import raise_for_type, raise_if_none
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -70,16 +70,21 @@ class SimpleSO(BaseSO):
     creation_dt: datetime
 
 
-class ErrorSO(BaseSO):
-    class APIErrorCodes(Enumeration):
-        cannot_authorize = "CANNOT_AUTHORIZE"
-        unknown_error = "UNKNOWN_ERROR"
-        error_in_request = "ERROR_IN_REQUEST"
-        not_found = "NOT_FOUND"
+class BaseAPIErrorCodes(Enumeration):
+    cannot_authorize = "CANNOT_AUTHORIZE"
+    unknown_error = "UNKNOWN_ERROR"
+    error_in_request = "ERROR_IN_REQUEST"
+    not_found = "NOT_FOUND"
+
+
+class BaseAPIErrorSpecificationCodes(Enumeration):
+    pass
 
+
+class ErrorSO(BaseSO):
     has_error: bool = True
     error_code: str | None = None
-    error_code_specification: str | None = None
+    error_specification_code: str | None = None
     error_description: str | None = None
     error_data: dict[str, Any] = {}
 
@@ -93,6 +98,10 @@ class StoryLogSO(SimpleSO):
     title: str | None
     data: dict[str, Any]
 
+    @classmethod
+    def from_story_log_dbm(cls, *, story_log_dbm: StoryLogDBM) -> StoryLogSO:
+        return cls.model_validate(story_log_dbm.simple_dict(include_sd_properties=True))
+
 
 class OperationSO(SimpleSO):
     execution_start_dt: datetime | None
@@ -104,13 +113,29 @@ class OperationSO(SimpleSO):
     error_data: dict[str, Any]
     duration_total_seconds: float | None
 
+    @classmethod
+    def from_operation_dbm(cls, *, operation_dbm: OperationDBM) -> OperationSO:
+        return cls.model_validate(operation_dbm.simple_dict(include_sd_properties=True))
+
 
 class APIJSONResponse(fastapi.responses.JSONResponse):
-    def __init__(self, *, content: BaseSO, status_code: int = starlette.status.HTTP_200_OK):
+    def __init__(self, *, content: dict | list | BaseSO | None, status_code: int = starlette.status.HTTP_200_OK):
+        if isinstance(content, dict):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content)
+        elif isinstance(content, list):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content)
+        elif isinstance(content, BaseSO):
+            content = safely_transfer_obj_to_json_str_to_json_obj(content.model_dump())
+        elif content is None:
+            content = None
+        else:
+            raise ValueError(f"unknown content type, type(content)={type(content)}")
+
         self.content_ = content
         self.status_code_ = status_code
+
         super().__init__(
-            content=safely_transfer_to_json_str_to_json_obj(content.model_dump()),
+            content=content,
             status_code=status_code
         )
 
@@ -120,14 +145,14 @@ class APIException(fastapi.exceptions.HTTPException):
             self,
             *,
             status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
-            error_code: str | None = ErrorSO.APIErrorCodes.unknown_error,
-            error_code_specification: str | None = None,
+            error_code: str | None = BaseAPIErrorCodes.unknown_error,
+            error_specification_code: str | None = None,
             error_description: str | None = None,
             error_data: dict[str, Any] | None = None
     ):
         self.status_code = status_code
         self.error_code = error_code
-        self.error_code_specification = error_code_specification
+        self.error_specification_code = error_specification_code
         self.error_description = error_description
         if error_data is None:
             error_data = {}
@@ -136,7 +161,7 @@ class APIException(fastapi.exceptions.HTTPException):
         self.error_so = ErrorSO(
             has_error=True,
             error_code=self.error_code,
-            error_specification=self.error_code_specification,
+            error_specification_code=self.error_specification_code,
             error_description=self.error_description,
             error_data=self.error_data
         )
@@ -149,14 +174,16 @@ class APIException(fastapi.exceptions.HTTPException):
 
 def create_handle_exception(
         *,
-        funcs_before_response: list[Callable] | None = None,
-        async_funcs_after_response: list[Callable] | None = None,
-) -> Any:
+        funcs_before_response: list[Callable | None] | None = None,
+        async_funcs_after_response: list[Callable | None] | None = None,
+) -> Callable:
     if funcs_before_response is None:
         funcs_before_response = []
+    funcs_before_response = [v for v in funcs_before_response if v is not None]
 
     if async_funcs_after_response is None:
         async_funcs_after_response = []
+    async_funcs_after_response = [v for v in async_funcs_after_response if v is not None]
 
     async def handle_exception(
             request: starlette.requests.Request, exception: Exception
@@ -165,12 +192,13 @@ def create_handle_exception(
 
         error_so = ErrorSO(
             has_error=True,
-            error_code=ErrorSO.APIErrorCodes.unknown_error,
+            error_code=BaseAPIErrorCodes.unknown_error,
             error_data={
                 "exception_type": str(type(exception)),
                 "exception_str": str(exception),
                 "request.method": str(request.method),
                 "request.url": str(request.url),
+                "request.headers": str(request.headers),
             }
         )
 
@@ -183,10 +211,10 @@ def create_handle_exception(
         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
+                error_so.error_code = BaseAPIErrorCodes.cannot_authorize
                 _need_exc_info = False
             elif status_code == starlette.status.HTTP_404_NOT_FOUND:
-                error_so.error_code = ErrorSO.APIErrorCodes.not_found
+                error_so.error_code = BaseAPIErrorCodes.not_found
                 _need_exc_info = False
             else:
                 status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
@@ -196,25 +224,31 @@ def create_handle_exception(
 
         elif isinstance(exception, fastapi.exceptions.RequestValidationError):
             status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
-            error_so.error_code = ErrorSO.APIErrorCodes.error_in_request
+            error_so.error_code = BaseAPIErrorCodes.error_in_request
             with suppress(Exception):
                 error_so.error_data["exception.errors"] = str(exception.errors()) if exception.errors() else {}
             _need_exc_info = False
 
         else:
             status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
-            error_so.error_code = ErrorSO.APIErrorCodes.unknown_error
+            error_so.error_code = BaseAPIErrorCodes.unknown_error
             _logger.exception(exception)
             _need_exc_info = True
 
         if error_so.error_code:
             error_so.error_code = 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 error_so.error_specification_code:
+            error_so.error_specification_code = (
+                error_so.error_specification_code.upper().replace(" ", "_").strip()
             )
 
+        if error_so.error_code == BaseAPIErrorCodes.not_found:
+            status_code = status.HTTP_404_NOT_FOUND
+
+        if error_so.error_code == BaseAPIErrorCodes.cannot_authorize:
+            status_code = status.HTTP_401_UNAUTHORIZED
+
         if _need_exc_info:
             _logger.error(str(exception), exc_info=exception)
         else:
@@ -225,7 +259,7 @@ def create_handle_exception(
             _func_data = func(
                 status_code=status_code, error_so=error_so, request=request, exception=exception, **_kwargs
             )
-            if asyncio.iscoroutine(_func_data):
+            if is_async_function(_func_data):
                 _func_data = await _func_data
             if _func_data is not None:
                 status_code, error_so, _kwargs = _func_data[0], _func_data[1], _func_data[2]
@@ -247,11 +281,12 @@ def create_handle_exception(
     return handle_exception
 
 
-def create_handle_exception_creating_story_log(
+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 handle_exception(
+    def func(
             *,
             status_code: int,
             error_so: ErrorSO,
@@ -259,6 +294,8 @@ def create_handle_exception_creating_story_log(
             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:
@@ -277,7 +314,7 @@ def create_handle_exception_creating_story_log(
         kwargs["story_log_id"] = story_log_dbm.id
         return status_code, error_so, kwargs
 
-    return handle_exception
+    return func
 
 
 def add_exception_handler_to_app(*, app: FastAPI, handle_exception: Callable) -> FastAPI:
@@ -349,7 +386,7 @@ def add_needed_api_router_to_app(*, app: FastAPI):
 
     @api_router.get(
         "/healthcheck",
-        response_model=ErrorSO,
+        response_model=RawDataSO | ErrorSO,
         status_code=starlette.status.HTTP_200_OK,
         tags=["Healthcheck"]
     )
@@ -361,14 +398,14 @@ def add_needed_api_router_to_app(*, app: FastAPI):
 
     @api_router.get(
         "/arpakitlib",
-        response_model=ErrorSO,
+        response_model=RawDataSO | 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"})
+            content=RawDataSO(data={"arpakitlib": True})
         )
 
     app.include_router(router=api_router, prefix="")
@@ -399,140 +436,221 @@ class InitSqlalchemyDBStartupAPIEvent(BaseStartupAPIEvent):
         super().__init__()
         self.sqlalchemy_db = sqlalchemy_db
 
-    def async_on_startup(self, *args, **kwargs):
+    async def async_on_startup(self, *args, **kwargs):
         self.sqlalchemy_db.init()
 
 
-class SyncSafeRunWorkerStartupAPIEvent(BaseStartupAPIEvent):
-    def __init__(self, worker: BaseWorker):
+class SafeRunWorkerStartupAPIEvent(BaseStartupAPIEvent):
+    def __init__(self, workers: list[BaseWorker], safe_run_in_background_mode: str):
         super().__init__()
-        self.worker = worker
+        self.workers = workers
+        self.safe_run_in_background_mode = safe_run_in_background_mode
 
-    def async_on_startup(self, *args, **kwargs):
-        thread = threading.Thread(
-            target=self.worker.sync_safe_run,
-            daemon=True
-        )
-        thread.start()
+    async def async_on_startup(self, *args, **kwargs):
+        for worker in self.workers:
+            _ = safe_run_worker_in_background(worker=worker, mode=SafeRunInBackgroundModes.async_task)
 
 
-class AsyncSafeRunWorkerStartupAPIEvent(BaseStartupAPIEvent):
-    def __init__(self, worker: ExecuteOperationWorker):
+class InitFileStoragesInDir(BaseStartupAPIEvent):
+    def __init__(self, file_storages_in_dir: list[FileStorageInDir | None]):
         super().__init__()
-        self.worker = worker
+        file_storages_in_dir = [v for v in file_storages_in_dir if v is not None]
+        self.file_storages_in_dir = file_storages_in_dir
 
-    def async_on_startup(self, *args, **kwargs):
-        _ = asyncio.create_task(self.worker.async_safe_run())
+    async def async_on_startup(self, *args, **kwargs):
+        for file_storage_in_dir in self.file_storages_in_dir:
+            file_storage_in_dir.init()
 
 
 class BaseTransmittedAPIData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
-    settings: SimpleSettings | None = None
-
-
-class SimpleTransmittedAPIData(BaseTransmittedAPIData):
-    sqlalchemy_db: SQLAlchemyDB | None = None
-
 
 def get_transmitted_api_data(request: starlette.requests.Request) -> BaseTransmittedAPIData:
     return request.app.state.transmitted_api_data
 
 
-class BaseNeedAPIAuthData(BaseModel):
+class BaseAPIAuthData(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
+    require_api_key_string: bool = False
+    require_token_string: bool = False
+
+    require_correct_api_key: bool = False
+    require_correct_token: bool = False
+
     token_string: str | None = None
     api_key_string: str | None = None
 
+    is_token_string_correct: bool | None = None
+    is_api_key_string_correct: bool | None = None
+
 
-def base_need_api_auth(
+def base_api_auth(
         *,
         require_api_key_string: bool = False,
         require_token_string: bool = False,
+        validate_api_key_func: Callable | None = None,
+        validate_token_func: Callable | None = None,
+        correct_api_keys: str | list[str] | None = None,
+        correct_tokens: str | list[str] | None = None,
+        require_correct_api_key: bool = False,
+        require_correct_token: bool = False,
+        **kwargs
 ) -> Callable:
+    if isinstance(correct_api_keys, str):
+        correct_api_keys = [correct_api_keys]
+    if correct_api_keys is not None:
+        raise_for_type(correct_api_keys, list)
+        validate_api_key_func = lambda *args, **kwargs_: kwargs_["api_key_string"] in correct_api_keys
+
+    if isinstance(correct_tokens, str):
+        correct_tokens = [correct_tokens]
+    if correct_tokens is not None:
+        raise_for_type(correct_tokens, list)
+        validate_token_func = lambda *args, **kwargs_: kwargs_["token_string"] in correct_tokens
+
+    if require_correct_api_key:
+        raise_if_none(validate_api_key_func)
+        require_api_key_string = True
+
+    if require_correct_token:
+        raise_if_none(validate_token_func)
+        require_token_string = True
+
     async def func(
             *,
             ac: fastapi.security.HTTPAuthorizationCredentials | None = fastapi.Security(
                 fastapi.security.HTTPBearer(auto_error=False)
             ),
             api_key_string: str | None = Security(APIKeyHeader(name="apikey", auto_error=False)),
-            request: fastapi.Request
-    ) -> BaseNeedAPIAuthData:
-
-        _error_data = {
-            "require_api_key_string": require_api_key_string,
-            "require_token_string": require_token_string
-        }
-
-        res = BaseNeedAPIAuthData()
+            request: starlette.requests.Request,
+            transmitted_api_data: BaseTransmittedAPIData = Depends(get_transmitted_api_data)
+    ) -> BaseAPIAuthData:
+
+        api_auth_data = BaseAPIAuthData(
+            require_api_key_string=require_api_key_string,
+            require_token_string=require_token_string,
+            require_correct_api_key=require_correct_api_key,
+            require_correct_token=require_correct_token
+        )
 
         # api_key
 
-        res.api_key_string = api_key_string
+        api_auth_data.api_key_string = api_key_string
 
-        if not res.api_key_string and "api_key" in request.headers.keys():
-            res.api_key_string = request.headers["api_key"]
-        if not res.api_key_string and "api-key" in request.headers.keys():
-            res.api_key_string = request.headers["api-key"]
-        if not res.api_key_string and "apikey" in request.headers.keys():
-            res.api_key_string = request.headers["apikey"]
+        if not api_auth_data.api_key_string and "api_key" in request.headers.keys():
+            api_auth_data.api_key_string = request.headers["api_key"]
+        if not api_auth_data.api_key_string and "api-key" in request.headers.keys():
+            api_auth_data.api_key_string = request.headers["api-key"]
+        if not api_auth_data.api_key_string and "apikey" in request.headers.keys():
+            api_auth_data.api_key_string = request.headers["apikey"]
 
-        if not res.api_key_string and "api_key" in request.query_params.keys():
-            res.api_key_string = request.query_params["api_key"]
-        if not res.api_key_string and "api-key" in request.query_params.keys():
-            res.api_key_string = request.query_params["api-key"]
-        if not res.api_key_string and "apikey" in request.query_params.keys():
-            res.api_key_string = request.query_params["apikey"]
-
-        _error_data["res.api_key_string"] = res.api_key_string
+        if not api_auth_data.api_key_string and "api_key" in request.query_params.keys():
+            api_auth_data.api_key_string = request.query_params["api_key"]
+        if not api_auth_data.api_key_string and "api-key" in request.query_params.keys():
+            api_auth_data.api_key_string = request.query_params["api-key"]
+        if not api_auth_data.api_key_string and "apikey" in request.query_params.keys():
+            api_auth_data.api_key_string = request.query_params["apikey"]
 
         # token
 
-        res.token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
+        api_auth_data.token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
 
-        if not res.token_string and "token" in request.headers.keys():
-            res.token_string = request.headers["token"]
+        if not api_auth_data.token_string and "token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["token"]
 
-        if not res.token_string and "user_token" in request.headers.keys():
-            res.token_string = request.headers["user_token"]
-        if not res.token_string and "user-token" in request.headers.keys():
-            res.token_string = request.headers["user-token"]
-        if not res.token_string and "usertoken" in request.headers.keys():
-            res.token_string = request.headers["usertoken"]
+        if not api_auth_data.token_string and "user_token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["user_token"]
+        if not api_auth_data.token_string and "user-token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["user-token"]
+        if not api_auth_data.token_string and "usertoken" in request.headers.keys():
+            api_auth_data.token_string = request.headers["usertoken"]
 
-        if not res.token_string and "token" in request.query_params.keys():
-            res.token_string = request.query_params["token"]
+        if not api_auth_data.token_string and "token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["token"]
 
-        if not res.token_string and "user_token" in request.query_params.keys():
-            res.token_string = request.query_params["user_token"]
-        if not res.token_string and "user-token" in request.query_params.keys():
-            res.token_string = request.query_params["user-token"]
-        if not res.token_string and "usertoken" in request.query_params.keys():
-            res.token_string = request.query_params["usertoken"]
+        if not api_auth_data.token_string and "user_token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["user_token"]
+        if not api_auth_data.token_string and "user-token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["user-token"]
+        if not api_auth_data.token_string and "usertoken" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["usertoken"]
 
-        if res.token_string:
-            res.token_string = res.token_string.strip()
-        if not res.token_string:
-            res.token_string = None
+        if api_auth_data.token_string:
+            api_auth_data.token_string = api_auth_data.token_string.strip()
+        if not api_auth_data.token_string:
+            api_auth_data.token_string = None
 
-        _error_data["res.token_string"] = res.token_string
+        # api_key
 
-        if require_api_key_string and not res.api_key_string:
+        if require_api_key_string and not api_auth_data.api_key_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=ErrorSO.APIErrorCodes.cannot_authorize,
-                error_data=_error_data
+                error_code=BaseAPIErrorCodes.cannot_authorize,
+                error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
-        if require_token_string and not res.token_string:
+        # token
+
+        if require_token_string and not api_auth_data.token_string:
             raise APIException(
                 status_code=starlette.status.HTTP_401_UNAUTHORIZED,
-                error_code=ErrorSO.APIErrorCodes.cannot_authorize,
-                error_data=_error_data
+                error_code=BaseAPIErrorCodes.cannot_authorize,
+                error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
 
-        return res
+        # api_key
+
+        if validate_api_key_func is not None:
+            validate_api_key_func_data = validate_api_key_func(
+                api_key_string=api_auth_data.api_key_string,
+                token_string=api_auth_data.token_string,
+                base_api_auth_data=api_auth_data,
+                transmitted_api_data=transmitted_api_data,
+                request=request,
+                **kwargs
+            )
+            if is_async_object(validate_api_key_func_data):
+                validate_api_key_func_data = await validate_api_key_func_data
+            api_auth_data.is_api_key_string_correct = validate_api_key_func_data
+
+        # token
+
+        if validate_token_func is not None:
+            validate_token_func_data = validate_token_func(
+                api_key_string=api_auth_data.api_key_string,
+                token_string=api_auth_data.token_string,
+                base_api_auth_data=api_auth_data,
+                transmitted_api_data=transmitted_api_data,
+                request=request,
+                **kwargs
+            )
+            if is_async_object(validate_token_func_data):
+                validate_token_func_data_data = await validate_token_func_data
+            api_auth_data.is_token_string_correct = validate_token_func_data_data
+
+        # api_key
+
+        if require_correct_api_key:
+            if not api_auth_data.is_api_key_string_correct:
+                raise APIException(
+                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    error_code=BaseAPIErrorCodes.cannot_authorize,
+                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+                )
+
+        # token
+
+        if require_correct_token:
+            if not api_auth_data.is_token_string_correct:
+                raise APIException(
+                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    error_code=BaseAPIErrorCodes.cannot_authorize,
+                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+                )
+
+        return api_auth_data
 
     return func
 
@@ -554,7 +672,7 @@ def simple_api_router_for_testing():
     async def _():
         raise APIException(
             error_code="raise_fake_exception_2",
-            error_code_specification="raise_fake_exception_2",
+            error_specification_code="raise_fake_exception_2",
             error_description="raise_fake_exception_2"
         )
 
@@ -566,7 +684,7 @@ def simple_api_router_for_testing():
         raise Exception("raise_fake_exception_3")
 
     @router.get(
-        "/check_params",
+        "/check_params_1",
         response_model=ErrorSO
     )
     async def _(name: int = Query()):
@@ -575,8 +693,8 @@ def simple_api_router_for_testing():
     return router
 
 
-_DEFAULT_CONTACT = {
-    "name": "arpakit",
+DEFAULT_CONTACT = {
+    "name": "ARPAKIT Company",
     "email": "support@arpakit.com"
 }
 
@@ -586,23 +704,32 @@ def create_fastapi_app(
         title: str = "arpakitlib FastAPI",
         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[BaseShutdownAPIEvent] | None = None,
+        handle_exception_: Callable | None = None,
+        startup_api_events: list[BaseStartupAPIEvent | None] | None = None,
+        shutdown_api_events: list[BaseShutdownAPIEvent | None] | None = None,
         transmitted_api_data: BaseTransmittedAPIData = BaseTransmittedAPIData(),
         main_api_router: APIRouter = simple_api_router_for_testing(),
-        contact: dict[str, Any] | None = None
+        contact: dict[str, Any] | None = None,
+        media_dirpath: str | None = None,
+        static_dirpath: str | None = None
 ):
-    if contact is None:
-        contact = _DEFAULT_CONTACT
+    _logger.info("start create_fastapi_app")
 
     setup_normal_logging(log_filepath=log_filepath)
 
+    if handle_exception_ is None:
+        handle_exception_ = create_handle_exception()
+
+    if contact is None:
+        contact = DEFAULT_CONTACT
+
     if not startup_api_events:
         startup_api_events = [BaseStartupAPIEvent()]
+    startup_api_events = [v for v in startup_api_events if v is not None]
 
     if not shutdown_api_events:
         shutdown_api_events = [BaseShutdownAPIEvent()]
+    shutdown_api_events = [v for v in shutdown_api_events if v is not None]
 
     app = FastAPI(
         title=title,
@@ -615,27 +742,33 @@ def create_fastapi_app(
         contact=contact
     )
 
+    if media_dirpath is not None:
+        if not os.path.exists(media_dirpath):
+            os.makedirs(media_dirpath, exist_ok=True)
+        app.mount("/media", StaticFiles(directory=media_dirpath), name="media")
+
+    if static_dirpath is not None:
+        if not os.path.exists(static_dirpath):
+            os.makedirs(static_dirpath, exist_ok=True)
+        app.mount("/static", StaticFiles(directory=static_dirpath), name="static")
+
     app.state.transmitted_api_data = transmitted_api_data
 
     add_cors_to_app(app=app)
 
     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_app(
-            app=app,
-            handle_exception=create_handle_exception()
-        )
+    add_exception_handler_to_app(
+        app=app,
+        handle_exception=handle_exception_
+    )
 
     add_needed_api_router_to_app(app=app)
 
     app.include_router(router=main_api_router)
 
+    _logger.info("finish create_fastapi_app")
+
     return app