arpakitlib 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/auth.py

@@ -4,20 +4,16 @@ import fastapi
 import fastapi.exceptions
 import fastapi.responses
 import fastapi.security
-import starlette.exceptions
-import starlette.requests
-import starlette.requests
-import starlette.status
-from fastapi import Security, Depends
+from fastapi import Security
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel, ConfigDict
 
 from api.const import APIErrorCodes
 from api.exception import APIException
-from api.transmitted_api_data import TransmittedAPIData, get_transmitted_api_data
 from arpakitlib.ar_func_util import is_async_callable, is_sync_function
 from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
 from arpakitlib.ar_type_util import raise_for_type
+from core.settings import get_cached_settings
 
 
 class APIAuthData(BaseModel):
@@ -77,8 +73,7 @@ def api_auth(
             api_key_string: str | None = Security(
                 APIKeyHeader(name="apikey", auto_error=False)
             ),
-            request: starlette.requests.Request,
-            transmitted_api_data: TransmittedAPIData = Depends(get_transmitted_api_data)
+            request: fastapi.requests.Request
     ) -> APIAuthData:
 
         api_auth_data = APIAuthData(
@@ -139,7 +134,7 @@ def api_auth(
 
         if require_api_key_string and not api_auth_data.api_key_string:
             raise APIException(
-                status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
                 error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
@@ -148,7 +143,7 @@ def api_auth(
 
         if require_token_string and not api_auth_data.token_string:
             raise APIException(
-                status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                 error_code=APIErrorCodes.cannot_authorize,
                 error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
             )
@@ -159,7 +154,6 @@ def api_auth(
             if is_async_callable(validate_api_key_func):
                 api_auth_data.is_api_key_correct = await validate_api_key_func(
                     api_auth_data=api_auth_data,
-                    transmitted_api_data=transmitted_api_data,
                     request=request
                 )
             elif is_sync_function(validate_api_key_func):
@@ -173,7 +167,6 @@ def api_auth(
             if is_async_callable(validate_token_func):
                 api_auth_data.is_token_correct = await validate_token_func(
                     api_auth_data=api_auth_data,
-                    transmitted_api_data=transmitted_api_data,
                     request=request
                 )
             elif is_sync_function(validate_token_func):
@@ -186,7 +179,7 @@ def api_auth(
         if require_correct_api_key:
             if not api_auth_data.is_api_key_correct:
                 raise APIException(
-                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                     error_code=APIErrorCodes.cannot_authorize,
                     error_description="not api_auth_data.is_api_key_correct",
                     error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump()),
@@ -197,7 +190,7 @@ def api_auth(
         if require_correct_token:
             if not api_auth_data.is_token_correct:
                 raise APIException(
-                    status_code=starlette.status.HTTP_401_UNAUTHORIZED,
+                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
                     error_code=APIErrorCodes.cannot_authorize,
                     error_description="not api_auth_data.is_token_correct",
                     error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
@@ -208,36 +201,34 @@ def api_auth(
     return func
 
 
-def correct_api_key_from_settings__validate_api_key_func() -> Callable:
+def correct_api_keys_from_settings__validate_api_key_func() -> Callable:
     async def func(
             *,
             api_auth_data: APIAuthData,
-            transmitted_api_data: TransmittedAPIData,
-            request: starlette.requests.Request,
+            request: fastapi.requests.Request,
     ):
-        if transmitted_api_data.settings.api_correct_api_keys is None:
-            return True
+        if get_cached_settings().api_correct_api_keys is None:
+            return False
         if api_auth_data.api_key_string is None:
             return False
-        if api_auth_data.api_key_string.strip() not in transmitted_api_data.settings.api_correct_api_keys:
+        if api_auth_data.api_key_string.strip() not in get_cached_settings().api_correct_api_keys:
             return False
         return True
 
     return func
 
 
-def correct_token_from_settings__validate_api_key_func() -> Callable:
+def correct_tokens_from_settings__validate_api_key_func() -> Callable:
     async def func(
             *,
             api_auth_data: APIAuthData,
-            transmitted_api_data: TransmittedAPIData,
-            request: starlette.requests.Request,
+            request: fastapi.requests.Request,
     ):
-        if transmitted_api_data.settings.api_correct_tokens is None:
-            return True
+        if get_cached_settings().api_correct_tokens is None:
+            return False
         if api_auth_data.token_string is None:
             return False
-        if api_auth_data.token_string.strip() not in transmitted_api_data.settings.api_correct_tokens:
+        if api_auth_data.token_string.strip() not in get_cached_settings().api_correct_tokens:
             return False
         return True
 

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/create_api_app.py

@@ -2,30 +2,28 @@ import logging
 import os
 
 from fastapi import FastAPI
-from starlette.middleware.cors import CORSMiddleware
-from starlette.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
 
 from api.event import get_api_startup_events, get_api_shutdown_events
 from api.exception_handler import add_exception_handler_to_app
 from api.openapi_ui import add_local_openapi_ui_to_app
 from api.router.main_router import main_api_router
-from api.transmitted_api_data import get_cached_transmitted_api_data
 from core.const import ProjectPaths
+from core.settings import get_cached_settings
 from core.util import setup_logging
 
 _logger = logging.getLogger(__name__)
 
 
-def create_api_app() -> FastAPI:
+def create_api_app(*, prefix: str = "/api") -> FastAPI:
     setup_logging()
 
     _logger.info("start")
 
-    transmitted_api_data = get_cached_transmitted_api_data()
-
     api_app = FastAPI(
-        title=transmitted_api_data.settings.project_name,
-        description=transmitted_api_data.settings.project_name,
+        title=get_cached_settings().project_name,
+        description=get_cached_settings().project_name,
         docs_url=None,
         redoc_url=None,
         openapi_url="/openapi",
@@ -38,17 +36,6 @@ def create_api_app() -> FastAPI:
         },
     )
 
-    api_app.state.transmitted_api_data = transmitted_api_data
-
-    if transmitted_api_data.settings.media_dirpath is not None:
-        if not os.path.exists(transmitted_api_data.settings.media_dirpath):
-            os.makedirs(transmitted_api_data.settings.media_dirpath, exist_ok=True)
-        api_app.mount("/media", StaticFiles(directory=transmitted_api_data.settings.media_dirpath), name="media")
-
-    if not os.path.exists(ProjectPaths.static_dirpath):
-        os.makedirs(ProjectPaths.static_dirpath, exist_ok=True)
-    api_app.mount("/static", StaticFiles(directory=ProjectPaths.static_dirpath), name="static")
-
     api_app.add_middleware(
         CORSMiddleware,
         allow_origins=["*"],
@@ -61,11 +48,23 @@ def create_api_app() -> FastAPI:
 
     add_exception_handler_to_app(app=api_app)
 
-    api_app.include_router(router=main_api_router)
+    api_app.include_router(
+        prefix=prefix,
+        router=main_api_router
+    )
+
+    if get_cached_settings().media_dirpath is not None:
+        if not os.path.exists(get_cached_settings().media_dirpath):
+            os.makedirs(get_cached_settings().media_dirpath, exist_ok=True)
+        api_app.mount("/media", StaticFiles(directory=get_cached_settings().media_dirpath), name="media")
+
+    if not os.path.exists(ProjectPaths.static_dirpath):
+        os.makedirs(ProjectPaths.static_dirpath, exist_ok=True)
+    api_app.mount("/static", StaticFiles(directory=ProjectPaths.static_dirpath), name="static")
 
-    if transmitted_api_data.settings.api_enable_admin1:
-        from admin1.add_admin_in_app import add_admin1_in_app
-        add_admin1_in_app(app=api_app)
+    if get_cached_settings().api_enable_sqladmin:
+        from sqladmin_.add_admin_in_app import add_sqladmin_in_app
+        add_sqladmin_in_app(app=api_app)
 
     _logger.info("finish")
 

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/event.py

@@ -1,10 +1,15 @@
 import logging
 from typing import Callable
 
-from api.transmitted_api_data import get_cached_transmitted_api_data
 from arpakitlib.ar_base_worker_util import safe_run_worker_in_background, SafeRunInBackgroundModes
+from core.cache_file_storage_in_dir import get_cached_cache_file_storage_in_dir
+from core.dump_file_storage_in_dir import get_cached_dump_file_storage_in_dir
+from core.media_file_storage_in_dir import get_cached_media_file_storage_in_dir
+from core.settings import get_cached_settings
+from json_db.json_db import get_cached_json_db
 from operation_execution.operation_executor_worker import create_operation_executor_worker
 from operation_execution.scheduled_operation_creator_worker import create_scheduled_operation_creator_worker
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
 
 _logger = logging.getLogger(__name__)
 
@@ -15,34 +20,34 @@ _logger = logging.getLogger(__name__)
 async def async_api_startup_event():
     _logger.info("start")
 
-    if get_cached_transmitted_api_data().media_file_storage_in_dir is not None:
-        get_cached_transmitted_api_data().media_file_storage_in_dir.init()
+    if get_cached_media_file_storage_in_dir() is not None:
+        get_cached_media_file_storage_in_dir().init()
 
-    if get_cached_transmitted_api_data().cache_file_storage_in_dir is not None:
-        get_cached_transmitted_api_data().cache_file_storage_in_dir.init()
+    if get_cached_cache_file_storage_in_dir() is not None:
+        get_cached_cache_file_storage_in_dir().init()
 
-    if get_cached_transmitted_api_data().dump_file_storage_in_dir is not None:
-        get_cached_transmitted_api_data().dump_file_storage_in_dir.init()
+    if get_cached_dump_file_storage_in_dir() is not None:
+        get_cached_dump_file_storage_in_dir().init()
 
     if (
-            get_cached_transmitted_api_data().sqlalchemy_db is not None
-            and get_cached_transmitted_api_data().settings.api_init_sqlalchemy_db
+            get_cached_sqlalchemy_db() is not None
+            and get_cached_settings().api_init_sqlalchemy_db
     ):
-        get_cached_transmitted_api_data().sqlalchemy_db.init()
+        get_cached_sqlalchemy_db().init()
 
     if (
-            get_cached_transmitted_api_data().json_db is not None
-            and get_cached_transmitted_api_data().settings.api_init_json_db
+            get_cached_json_db() is not None
+            and get_cached_settings().api_init_json_db
     ):
-        get_cached_transmitted_api_data().json_db.init()
+        get_cached_json_db().init()
 
-    if get_cached_transmitted_api_data().settings.api_start_operation_executor_worker:
+    if get_cached_settings().api_start_operation_executor_worker:
         _ = safe_run_worker_in_background(
             worker=create_operation_executor_worker(),
             mode=SafeRunInBackgroundModes.thread
         )
 
-    if get_cached_transmitted_api_data().settings.api_start_scheduled_operation_creator_worker:
+    if get_cached_settings().api_start_scheduled_operation_creator_worker:
         _ = safe_run_worker_in_background(
             worker=create_scheduled_operation_creator_worker(),
             mode=SafeRunInBackgroundModes.async_task

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/exception.py

@@ -1,7 +1,6 @@
 from typing import Any
 
 import fastapi.security
-import starlette.status
 
 from api.const import APIErrorCodes
 from api.schema.common.out import ErrorCommonSO
@@ -11,7 +10,7 @@ class APIException(fastapi.exceptions.HTTPException):
     def __init__(
             self,
             *,
-            status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
+            status_code: int = fastapi.status.HTTP_400_BAD_REQUEST,
             error_code: str | None = APIErrorCodes.unknown_error,
             error_specification_code: str | None = None,
             error_description: str | None = None,

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/exception_handler.py

@@ -4,15 +4,8 @@ import logging
 from contextlib import suppress
 from typing import Any, Callable
 
-import fastapi.exceptions
-import fastapi.exceptions
-import fastapi.responses
-import fastapi.security
+import fastapi
 import starlette.exceptions
-import starlette.exceptions
-import starlette.requests
-import starlette.status
-from fastapi import FastAPI
 
 from api.const import APIErrorCodes
 from api.exception import APIException
@@ -45,10 +38,10 @@ def create_exception_handler(
     async_funcs_after = [v for v in async_funcs_after if v is not None]
 
     async def func(
-            request: starlette.requests.Request,
+            request: fastapi.requests.Request,
             exception: Exception
     ) -> APIJSONResponse:
-        status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+        status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
 
         error_common_so = ErrorCommonSO(
             has_error=True,
@@ -66,25 +59,28 @@ def create_exception_handler(
             error_common_so = exception.error_common_so
             error_common_so.error_data = combine_dicts(old_error_data, error_common_so.error_data)
 
-        elif isinstance(exception, starlette.exceptions.HTTPException):
+        elif (
+                isinstance(exception, fastapi.exceptions.HTTPException)
+                or isinstance(exception, starlette.exceptions.HTTPException)
+        ):
             status_code = exception.status_code
-            if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
+            if status_code in (fastapi.status.HTTP_403_FORBIDDEN, fastapi.status.HTTP_401_UNAUTHORIZED):
                 error_common_so.error_code = APIErrorCodes.cannot_authorize
-            elif status_code == starlette.status.HTTP_404_NOT_FOUND:
+            elif status_code == fastapi.status.HTTP_404_NOT_FOUND:
                 error_common_so.error_code = APIErrorCodes.not_found
             else:
-                status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+                status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
             with suppress(Exception):
                 error_common_so.error_data["exception.detail"] = exception.detail
 
         elif isinstance(exception, fastapi.exceptions.RequestValidationError):
-            status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
+            status_code = fastapi.status.HTTP_422_UNPROCESSABLE_ENTITY
             error_common_so.error_code = APIErrorCodes.error_in_request
             with suppress(Exception):
                 error_common_so.error_data["exception.errors"] = str(exception.errors()) if exception.errors() else {}
 
         else:
-            status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+            status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
             error_common_so.error_code = APIErrorCodes.unknown_error
 
         if error_common_so.error_code is not None:
@@ -96,10 +92,10 @@ def create_exception_handler(
             )
 
         if error_common_so.error_code == APIErrorCodes.not_found:
-            status_code = starlette.status.HTTP_404_NOT_FOUND
+            status_code = fastapi.status.HTTP_404_NOT_FOUND
 
         if error_common_so.error_code == APIErrorCodes.cannot_authorize:
-            status_code = starlette.status.HTTP_401_UNAUTHORIZED
+            status_code = fastapi.status.HTTP_401_UNAUTHORIZED
 
         error_common_so.error_data["status_code"] = status_code
 
@@ -108,15 +104,23 @@ def create_exception_handler(
         _transmitted_kwargs = {}
         for func_before in funcs_before:
             if is_async_callable(func_before):
-                _func_before_res = await func_before(
-                    request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
-                    transmitted_kwargs=_transmitted_kwargs
-                )
+                try:
+                    _func_before_res = await func_before(
+                        request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
+                        transmitted_kwargs=_transmitted_kwargs
+                    )
+                except Exception as exception_:
+                    _logger.exception(exception_)
+                    raise exception_
             elif is_sync_function(func_before):
-                _func_before_res = func_before(
-                    request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
-                    transmitted_kwargs=_transmitted_kwargs
-                )
+                try:
+                    _func_before_res = func_before(
+                        request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
+                        transmitted_kwargs=_transmitted_kwargs
+                    )
+                except Exception as exception_:
+                    _logger.exception(exception_)
+                    raise exception_
             else:
                 raise TypeError("unknown func_before type")
             if _func_before_res is not None:
@@ -150,7 +154,7 @@ def logging__api_func_before_in_handle_exception(
 
     def func(
             *,
-            request: starlette.requests.Request,
+            request: fastapi.requests.Request,
             status_code: int,
             error_common_so: ErrorCommonSO,
             exception: Exception,
@@ -185,7 +189,7 @@ def story_log__api_func_before_in_handle_exception(
 
     async def async_func(
             *,
-            request: starlette.requests.Request,
+            request: fastapi.requests.Request,
             status_code: int,
             error_common_so: ErrorCommonSO,
             exception: Exception,
@@ -231,7 +235,10 @@ def get_exception_handler() -> Callable:
     funcs_before = []
     async_funcs_after = []
 
-    if get_cached_settings().api_story_log__api_func_before_in_exception_handler:
+    if (
+            get_cached_settings().api_story_log__api_func_before_in_exception_handler
+            and get_cached_sqlalchemy_db() is not None
+    ):
         funcs_before.append(
             story_log__api_func_before_in_handle_exception(
                 ignore_api_error_codes=[
@@ -240,9 +247,9 @@ def get_exception_handler() -> Callable:
                     APIErrorCodes.not_found
                 ],
                 ignore_status_codes=[
-                    starlette.status.HTTP_401_UNAUTHORIZED,
-                    starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
-                    starlette.status.HTTP_404_NOT_FOUND
+                    fastapi.status.HTTP_401_UNAUTHORIZED,
+                    fastapi.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    fastapi.status.HTTP_404_NOT_FOUND
                 ],
                 ignore_exception_types=[
                     fastapi.exceptions.RequestValidationError
@@ -258,9 +265,9 @@ def get_exception_handler() -> Callable:
                 APIErrorCodes.not_found
             ],
             ignore_status_codes=[
-                starlette.status.HTTP_401_UNAUTHORIZED,
-                starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
-                starlette.status.HTTP_404_NOT_FOUND
+                fastapi.status.HTTP_401_UNAUTHORIZED,
+                fastapi.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                fastapi.status.HTTP_404_NOT_FOUND
             ],
             ignore_exception_types=[
                 fastapi.exceptions.RequestValidationError
@@ -274,7 +281,7 @@ def get_exception_handler() -> Callable:
     )
 
 
-def add_exception_handler_to_app(*, app: FastAPI) -> FastAPI:
+def add_exception_handler_to_app(*, app: fastapi.FastAPI) -> fastapi.FastAPI:
     exception_handler = get_exception_handler()
 
     app.add_exception_handler(
@@ -289,6 +296,10 @@ def add_exception_handler_to_app(*, app: FastAPI) -> FastAPI:
         exc_class_or_status_code=fastapi.exceptions.RequestValidationError,
         handler=exception_handler
     )
+    app.add_exception_handler(
+        exc_class_or_status_code=fastapi.exceptions.HTTPException,
+        handler=exception_handler
+    )
     app.add_exception_handler(
         exc_class_or_status_code=starlette.exceptions.HTTPException,
         handler=exception_handler

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/response.py

@@ -1,12 +1,16 @@
-import fastapi.security
-import starlette.status
+from typing import Any
+
+import fastapi
 
 from api.schema.v1.out import BaseSO
 from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
 
 
 class APIJSONResponse(fastapi.responses.JSONResponse):
-    def __init__(self, *, content: dict | list | BaseSO | None, status_code: int = starlette.status.HTTP_200_OK):
+    def __init__(
+            self, *,
+            content: dict[str, Any] | list[Any] | BaseSO | None, status_code: int = fastapi.status.HTTP_200_OK
+    ):
         if isinstance(content, dict):
             content = safely_transfer_obj_to_json_str_to_json_obj(content)
         elif isinstance(content, list):

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/router/main_router.py

@@ -8,6 +8,6 @@ main_api_router = APIRouter()
 
 
 main_api_router.include_router(
+    prefix="/v1",
     router=main_v1_api_router,
-    prefix="/api/v1"
 )

arpakitlib/_arpakit_project_template_v_1/api/router/v1/arpakit_project_template.py

@@ -0,0 +1,22 @@
+import fastapi
+from fastapi import APIRouter
+
+from api.schema.common.out import ErrorCommonSO, RawDataCommonSO
+from util.read_arpakitlib_project_template_file import read_arpakitlib_project_template_file
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get arpakitlib info",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=RawDataCommonSO | ErrorCommonSO
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    arpakitlib_project_template_data = read_arpakitlib_project_template_file()
+    return RawDataCommonSO(data=arpakitlib_project_template_data)

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/router/v1/check_auth.py

@@ -1,18 +1,18 @@
 import fastapi.requests
 from fastapi import APIRouter, Depends
-from starlette import status
 
-from api.auth import APIAuthData, api_auth, correct_api_key_from_settings__validate_api_key_func, \
-    correct_token_from_settings__validate_api_key_func
+from api.auth import APIAuthData, api_auth, correct_api_keys_from_settings__validate_api_key_func, \
+    correct_tokens_from_settings__validate_api_key_func
 from api.schema.common.out import ErrorCommonSO, RawDataCommonSO
 
 api_router = APIRouter()
 
 
 @api_router.get(
-    "",
+    path="",
+    name="Check auth",
+    status_code=fastapi.status.HTTP_200_OK,
     response_model=RawDataCommonSO | ErrorCommonSO,
-    status_code=status.HTTP_200_OK
 )
 async def _(
         *,
@@ -21,8 +21,8 @@ async def _(
         api_auth_data: APIAuthData = Depends(api_auth(
             require_api_key_string=False,
             require_token_string=False,
-            validate_api_key_func=correct_api_key_from_settings__validate_api_key_func(),
-            validate_token_func=correct_token_from_settings__validate_api_key_func(),
+            validate_api_key_func=correct_api_keys_from_settings__validate_api_key_func(),
+            validate_token_func=correct_tokens_from_settings__validate_api_key_func(),
             require_correct_api_key=False,
             require_correct_token=False,
         ))

arpakitlib/_arpakit_project_template_v_1/api/router/v1/clear_log_file.py

@@ -0,0 +1,25 @@
+import fastapi
+from fastapi import APIRouter
+
+from api.schema.common.out import RawDataCommonSO, ErrorCommonSO
+from arpakitlib.ar_logging_util import init_log_file
+from core.settings import get_cached_settings
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    path="",
+    name="Clear log file",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=RawDataCommonSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    init_log_file(log_filepath=get_cached_settings().log_filepath)
+    with open(file=get_cached_settings().log_filepath, mode="w") as f:
+        f.write("")
+    return RawDataCommonSO(data={"log_file_was_cleared": True})

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/router/v1/get_errors_info.py

@@ -1,6 +1,5 @@
 import fastapi.requests
 from fastapi import APIRouter
-from starlette import status
 
 from api.const import APIErrorCodes, APIErrorSpecificationCodes
 from api.schema.common.out import ErrorCommonSO, ErrorsInfoCommonSO
@@ -10,8 +9,9 @@ api_router = APIRouter()
 
 @api_router.get(
     "",
+    name="Get errors info",
+    status_code=fastapi.status.HTTP_200_OK,
     response_model=ErrorsInfoCommonSO | ErrorCommonSO,
-    status_code=status.HTTP_200_OK
 )
 async def _(
         *,

arpakitlib/_arpakit_project_template_v_1/api/router/v1/get_log_file.py

@@ -0,0 +1,23 @@
+import fastapi
+from fastapi import APIRouter
+from fastapi.responses import FileResponse
+
+from arpakitlib.ar_logging_util import init_log_file
+from core.settings import get_cached_settings
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    path="",
+    name="Get log file",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_class=FileResponse
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    init_log_file(log_filepath=get_cached_settings().log_filepath)
+    return FileResponse(path=get_cached_settings().log_filepath)

arpakitlib/{_arpakit_project_template_v1 → _arpakit_project_template_v_1}/api/router/v1/healthcheck.py

@@ -1,5 +1,4 @@
 import fastapi
-import starlette.status
 from fastapi import APIRouter
 
 from api.schema.common.out import ErrorCommonSO
@@ -10,8 +9,9 @@ api_router = APIRouter()
 
 @api_router.get(
     "",
+    name="Healthcheck",
+    status_code=fastapi.status.HTTP_200_OK,
     response_model=HealthcheckV1SO | ErrorCommonSO,
-    status_code=starlette.status.HTTP_200_OK
 )
 async def _(
         *,