arpakitlib 1.8.14__py3-none-any.whl → 1.8.16__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_4/project/api/auth2.py

@@ -0,0 +1,171 @@
+from typing import Callable
+
+import fastapi
+import fastapi.exceptions
+import fastapi.responses
+import fastapi.security
+from fastapi import Security
+from fastapi.security import APIKeyHeader
+from pydantic import BaseModel, ConfigDict
+
+from arpakitlib.ar_func_util import is_async_callable, is_sync_function
+from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
+from project.api.const import APIErrorCodes
+from project.api.exception import APIException
+from project.core.settings import get_cached_settings
+
+
+class APIAuthData(BaseModel):
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+
+    api_key_string: str | None = None
+    user_token_string: str | None = None
+
+    prod_mode: bool = False
+
+
+def api_auth(
+        *,
+        middleware_funcs: list[Callable] | None = None
+) -> Callable:
+    if middleware_funcs is None:
+        middleware_funcs = []
+
+    async def async_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.requests.Request
+    ) -> APIAuthData:
+
+        api_auth_data = APIAuthData(
+            prod_mode=get_cached_settings().prod_mode
+        )
+
+        # parse api_key
+
+        api_auth_data.api_key_string = api_key_string
+
+        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 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"]
+
+        if api_auth_data.api_key_string:
+            api_auth_data.api_key_string = api_auth_data.api_key_string.strip()
+        if not api_auth_data.api_key_string:
+            api_auth_data.api_key_string = None
+
+        # parse user_token
+
+        api_auth_data.user_token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
+
+        if not api_auth_data.user_token_string and "token" in request.headers.keys():
+            api_auth_data.user_token_string = request.headers["token"]
+
+        if not api_auth_data.user_token_string and "user_token" in request.headers.keys():
+            api_auth_data.user_token_string = request.headers["user_token"]
+        if not api_auth_data.user_token_string and "user-token" in request.headers.keys():
+            api_auth_data.user_token_string = request.headers["user-token"]
+        if not api_auth_data.user_token_string and "usertoken" in request.headers.keys():
+            api_auth_data.user_token_string = request.headers["usertoken"]
+
+        if not api_auth_data.user_token_string and "token" in request.query_params.keys():
+            api_auth_data.user_token_string = request.query_params["token"]
+
+        if not api_auth_data.user_token_string and "user_token" in request.query_params.keys():
+            api_auth_data.user_token_string = request.query_params["user_token"]
+        if not api_auth_data.user_token_string and "user-token" in request.query_params.keys():
+            api_auth_data.user_token_string = request.query_params["user-token"]
+        if not api_auth_data.user_token_string and "usertoken" in request.query_params.keys():
+            api_auth_data.user_token_string = request.query_params["usertoken"]
+
+        if api_auth_data.user_token_string:
+            api_auth_data.user_token_string = api_auth_data.user_token_string.strip()
+        if not api_auth_data.user_token_string:
+            api_auth_data.user_token_string = None
+
+        # middleware_funcs
+
+        for middleware_func in middleware_funcs:
+            if is_async_callable(middleware_func):
+                await middleware_func(
+                    api_auth_data=api_auth_data,
+                    request=request
+                )
+            elif is_sync_function(middleware_func):
+                middleware_func(
+                    api_auth_data=api_auth_data,
+                    request=request
+                )
+            else:
+                raise TypeError("unknown middleware_func type")
+
+        return api_auth_data
+
+    return async_func
+
+
+def require_api_key_string_middleware_func():
+    def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if api_auth_data.api_key_string is None:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="api_key string is required",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return func
+
+
+def require_user_token_string_middleware_func():
+    def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if api_auth_data.user_token_string is None:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description="user_token string is required",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return func
+
+
+def require_prod_mode_middleware_func():
+    def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if not get_cached_settings().prod_mode:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description=f"prod_mode={get_cached_settings().prod_mode}",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return func
+
+
+def require_not_prod_mode_middleware_func():
+    def func(*, api_auth_data: APIAuthData, request: fastapi.requests.Request):
+        if get_cached_settings().prod_mode:
+            raise APIException(
+                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
+                error_code=APIErrorCodes.cannot_authorize,
+                error_description=f"prod_mode={get_cached_settings().prod_mode}",
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
+            )
+
+    return func

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/create_api_app.py

@@ -5,9 +5,9 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
 
-from project.api.event import get_api_startup_events, get_api_shutdown_events
-from project.api.exception_handler import add_exception_handler_to_app
-from project.api.openapi_ui import add_local_openapi_ui_to_app
+from project.api.event import get_startup_api_events, get_shutdown_api_events
+from project.api.exception_handler import add_exception_handler_to_api_app
+from project.api.openapi_ui import add_local_openapi_ui_to_api_app
 from project.api.router.main_router import main_api_router
 from project.core.const import ProjectPaths
 from project.core.settings import get_cached_settings
@@ -27,8 +27,8 @@ def create_api_app(*, prefix: str = "/api") -> FastAPI:
         docs_url=None,
         redoc_url=None,
         openapi_url="/openapi",
-        on_startup=get_api_startup_events(),
-        on_shutdown=get_api_shutdown_events(),
+        on_startup=get_startup_api_events(),
+        on_shutdown=get_shutdown_api_events(),
         contact={
             "name": "ARPAKIT Company",
             "url": "https://arpakit.com/",
@@ -44,9 +44,9 @@ def create_api_app(*, prefix: str = "/api") -> FastAPI:
         allow_headers=["*"],
     )
 
-    add_local_openapi_ui_to_app(app=api_app)
+    add_local_openapi_ui_to_api_app(app=api_app)
 
-    add_exception_handler_to_app(app=api_app)
+    add_exception_handler_to_api_app(app=api_app)
 
     api_app.include_router(
         prefix=prefix,

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/event.py

@@ -14,10 +14,10 @@ from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 _logger = logging.getLogger(__name__)
 
 
-# STARTUP API EVENTS
+# API STARTUP EVENTS
 
 
-async def async_api_startup_event():
+async def async_startup_api_event():
     _logger.info("start")
 
     if get_cached_media_file_storage_in_dir() is not None:
@@ -56,19 +56,19 @@ async def async_api_startup_event():
     _logger.info("finish")
 
 
-def get_api_startup_events() -> list[Callable]:
-    res = [async_api_startup_event]
+def get_startup_api_events() -> list[Callable]:
+    res = [async_startup_api_event]
     return res
 
 
-# SHUTDOWN API EVENTS
+# API SHUTDOWN EVENTS
 
 
-async def async_api_shutdown_event():
+async def async_shutdown_api_event():
     _logger.info("start")
     _logger.info("finish")
 
 
-def get_api_shutdown_events() -> list[Callable]:
-    res = [async_api_shutdown_event]
+def get_shutdown_api_events() -> list[Callable]:
+    res = [async_shutdown_api_event]
     return res

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/exception.py

@@ -1,9 +1,9 @@
 from typing import Any
 
 import fastapi.security
+from project.api.schema.out.common.error import ErrorCommonSO
 
 from project.api.const import APIErrorCodes
-from project.api.schema.common.out import ErrorCommonSO
 
 
 class APIException(fastapi.exceptions.HTTPException):

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/exception_handler.py

@@ -11,12 +11,11 @@ from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_exception_util import exception_to_traceback_str
 from arpakitlib.ar_func_util import raise_if_not_async_callable, is_async_callable, is_sync_function
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
-from arpakitlib.ar_type_util import raise_for_type
+from arpakitlib.ar_json_util import transfer_data_to_json_str
 from project.api.const import APIErrorCodes
 from project.api.exception import APIException
 from project.api.response import APIJSONResponse
-from project.api.schema.common.out import ErrorCommonSO
+from project.api.schema.out.general.error import ErrorGeneralSO
 from project.core.settings import get_cached_settings
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
@@ -24,7 +23,7 @@ from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
 _logger = logging.getLogger(__name__)
 
 
-def create_exception_handler(
+def create_api_exception_handler(
         *,
         funcs_before: list[Callable | None] | None = None,
         async_funcs_after: list[Callable | None] | None = None
@@ -37,13 +36,13 @@ def create_exception_handler(
         async_funcs_after = []
     async_funcs_after = [v for v in async_funcs_after if v is not None]
 
-    async def func(
+    async def async_func(
             request: fastapi.requests.Request,
             exception: Exception
     ) -> APIJSONResponse:
         status_code = fastapi.status.HTTP_500_INTERNAL_SERVER_ERROR
 
-        error_common_so = ErrorCommonSO(
+        error_common_so = ErrorGeneralSO(
             has_error=True,
             error_code=APIErrorCodes.unknown_error,
             error_data={
@@ -105,8 +104,11 @@ def create_exception_handler(
         for func_before in funcs_before:
             if is_async_callable(func_before):
                 try:
-                    _func_before_res = await func_before(
-                        request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
+                    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_:
@@ -114,8 +116,11 @@ def create_exception_handler(
                     raise exception_
             elif is_sync_function(func_before):
                 try:
-                    _func_before_res = func_before(
-                        request=request, status_code=status_code, error_common_so=error_common_so, exception=exception,
+                    func_before(
+                        request=request,
+                        status_code=status_code,
+                        error_common_so=error_common_so,
+                        exception=exception,
                         transmitted_kwargs=_transmitted_kwargs
                     )
                 except Exception as exception_:
@@ -123,10 +128,6 @@ def create_exception_handler(
                     raise exception_
             else:
                 raise TypeError("unknown func_before type")
-            if _func_before_res is not None:
-                error_common_so, _transmitted_kwargs = _func_before_res[0], _func_before_res[1]
-                raise_for_type(error_common_so, ErrorCommonSO)
-                raise_for_type(_transmitted_kwargs, dict)
 
         # async_funcs_after
 
@@ -141,10 +142,10 @@ def create_exception_handler(
             status_code=status_code
         )
 
-    return func
+    return async_func
 
 
-def logging__api_func_before_in_handle_exception(
+def logging_func_before_in_api_exception_handler(
         *,
         ignore_api_error_codes: list[str] | None = None,
         ignore_status_codes: list[int] | None = None,
@@ -156,30 +157,30 @@ def logging__api_func_before_in_handle_exception(
             *,
             request: fastapi.requests.Request,
             status_code: int,
-            error_common_so: ErrorCommonSO,
+            error_common_so: ErrorGeneralSO,
             exception: Exception,
             transmitted_kwargs: dict[str, Any],
             **kwargs
-    ) -> (ErrorCommonSO, dict[str, Any]):
+    ):
         transmitted_kwargs[current_func_name] = now_utc_dt()
 
         if ignore_api_error_codes is not None and error_common_so.error_code in ignore_api_error_codes:
-            return error_common_so, transmitted_kwargs
+            return
 
         if ignore_status_codes is not None and status_code in ignore_status_codes:
-            return error_common_so, transmitted_kwargs
+            return
 
         if ignore_exception_types is not None and (
                 exception in ignore_exception_types or type(exception) in ignore_exception_types
         ):
-            return error_common_so, transmitted_kwargs
+            return
 
-        _logger.error(safely_transfer_obj_to_json_str(error_common_so.model_dump()), exc_info=False)
+        _logger.error(transfer_data_to_json_str(error_common_so.model_dump()), exc_info=False)
 
     return func
 
 
-def story_log__api_func_before_in_handle_exception(
+def create_story_log_func_before_in_api_exception_handler(
         *,
         ignore_api_error_codes: list[str] | None = None,
         ignore_status_codes: list[int] | None = None,
@@ -191,32 +192,33 @@ def story_log__api_func_before_in_handle_exception(
             *,
             request: fastapi.requests.Request,
             status_code: int,
-            error_common_so: ErrorCommonSO,
+            error_common_so: ErrorGeneralSO,
             exception: Exception,
             transmitted_kwargs: dict[str, Any],
             **kwargs
-    ) -> (ErrorCommonSO, dict[str, Any]):
+    ):
         transmitted_kwargs[current_func_name] = now_utc_dt()
 
         if ignore_api_error_codes is not None and error_common_so.error_code in ignore_api_error_codes:
-            return error_common_so, transmitted_kwargs
+            return
 
         if ignore_status_codes is not None and status_code in ignore_status_codes:
-            return error_common_so, transmitted_kwargs
+            return
 
         if ignore_exception_types is not None and (
                 exception in ignore_exception_types or type(exception) in ignore_exception_types
         ):
-            return error_common_so, transmitted_kwargs
+            return
 
         async with get_cached_sqlalchemy_db().new_async_session() as session:
             story_log_dbm = StoryLogDBM(
                 level=StoryLogDBM.Levels.error,
-                type=StoryLogDBM.Types.error_in_api_route,
+                type=StoryLogDBM.Types.error_in_api,
                 title=f"{status_code}, {type(exception)}",
                 data={
+                    "exception_str": str(exception),
                     "error_common_so": error_common_so.model_dump(),
-                    "traceback_str": exception_to_traceback_str(exception=exception)
+                    "error_traceback_str": exception_to_traceback_str(exception=exception)
                 }
             )
             session.add(story_log_dbm)
@@ -226,7 +228,7 @@ def story_log__api_func_before_in_handle_exception(
         error_common_so.error_data.update({"story_log_long_id": story_log_dbm.long_id})
         transmitted_kwargs["story_log_id"] = story_log_dbm.id
 
-        return error_common_so, transmitted_kwargs
+        return
 
     return async_func
 
@@ -236,11 +238,11 @@ def get_exception_handler() -> Callable:
     async_funcs_after = []
 
     if (
-            get_cached_settings().api_story_log__api_func_before_in_exception_handler
+            get_cached_settings().api_create_story_log_func_before_in_api_exception_handler
             and get_cached_sqlalchemy_db() is not None
     ):
         funcs_before.append(
-            story_log__api_func_before_in_handle_exception(
+            create_story_log_func_before_in_api_exception_handler(
                 ignore_api_error_codes=[
                     APIErrorCodes.cannot_authorize,
                     APIErrorCodes.error_in_request,
@@ -258,7 +260,7 @@ def get_exception_handler() -> Callable:
         )
 
     funcs_before.append(
-        logging__api_func_before_in_handle_exception(
+        logging_func_before_in_api_exception_handler(
             ignore_api_error_codes=[
                 APIErrorCodes.cannot_authorize,
                 APIErrorCodes.error_in_request,
@@ -275,13 +277,13 @@ def get_exception_handler() -> Callable:
         )
     )
 
-    return create_exception_handler(
+    return create_api_exception_handler(
         funcs_before=funcs_before,
         async_funcs_after=async_funcs_after
     )
 
 
-def add_exception_handler_to_app(*, app: fastapi.FastAPI) -> fastapi.FastAPI:
+def add_exception_handler_to_api_app(*, app: fastapi.FastAPI) -> fastapi.FastAPI:
     exception_handler = get_exception_handler()
 
     app.add_exception_handler(

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/openapi_ui.py

@@ -2,7 +2,7 @@ from fastapi import FastAPI
 from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
 
 
-def add_local_openapi_ui_to_app(
+def add_local_openapi_ui_to_api_app(
         *,
         app: FastAPI
 ):

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/response.py

@@ -2,8 +2,8 @@ from typing import Any
 
 import fastapi
 
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
-from project.api.schema.base_schema import BaseSO
+from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
+from project.api.schema.common import BaseSO
 
 
 class APIJSONResponse(fastapi.responses.JSONResponse):
@@ -12,11 +12,11 @@ class APIJSONResponse(fastapi.responses.JSONResponse):
             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)
+            content = transfer_data_to_json_str_to_data(content)
         elif isinstance(content, list):
-            content = safely_transfer_obj_to_json_str_to_json_obj(content)
+            content = transfer_data_to_json_str_to_data(content)
         elif isinstance(content, BaseSO):
-            content = safely_transfer_obj_to_json_str_to_json_obj(content.model_dump())
+            content = transfer_data_to_json_str_to_data(content.model_dump())
         elif content is None:
             content = None
         else:

arpakitlib/_arpakit_project_template_v_4/project/api/router/admin/get_arpakitlib_project_template_info.py

@@ -0,0 +1,23 @@
+import fastapi
+from fastapi import APIRouter
+
+from project.api.schema.out.common.raw_data import RawDataCommonSO
+from project.api.schema.out.general.error import ErrorGeneralSO
+from project.util.arpakitlib_project_template import get_arpakitlib_project_template_info
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Get arpakitlib project template info",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=RawDataCommonSO | ErrorGeneralSO
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response
+):
+    arpakitlib_project_template_data = get_arpakitlib_project_template_info()
+    return RawDataCommonSO(data=arpakitlib_project_template_data)

arpakitlib/_arpakit_project_template_v_4/project/api/router/admin/get_auth_data.py

@@ -0,0 +1,30 @@
+import fastapi.requests
+from fastapi import APIRouter
+from project.api.schema.out.common.error import ErrorCommonSO
+
+from arpakitlib.ar_json_util import transfer_data_to_json_str_to_data
+from project.api.auth import APIAuthData, api_auth
+from project.api.schema.out.common.raw_data import RawDataCommonSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    path="",
+    name="Get auth data",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=RawDataCommonSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        api_auth_data: APIAuthData = fastapi.Depends(api_auth(
+            require_not_prod_mode=True,
+            try_find_api_key_dbm_from_sqlalchemy_db=True,
+            try_find_user_token_dbm_from_sqlalchemy_db=True,
+            require_api_key_dbm_from_sqlalchemy_db=True,
+            require_user_token_dbm_from_sqlalchemy_db=True
+        ))
+):
+    return RawDataCommonSO(data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()))

arpakitlib/_arpakit_project_template_v_4/project/api/router/admin/main_router.py

@@ -0,0 +1,3 @@
+from fastapi import APIRouter
+
+main_admin_api_router = APIRouter()

arpakitlib/{_arpakit_project_template_v_2/project/api/router/general → _arpakit_project_template_v_4/project/api/router/client}/get_errors_info.py

@@ -1,11 +1,9 @@
 import fastapi.requests
 from fastapi import APIRouter
+from project.api.schema.out.common.error import ErrorCommonSO
 
-from project.api.auth import APIAuthData, api_auth, \
-    correct_api_keys_from_settings__is_api_key_correct_func
 from project.api.const import APIErrorCodes, APIErrorSpecificationCodes
-from project.api.schema.common.out import ErrorCommonSO
-from project.api.schema.general.out import ErrorsInfoGeneralSO
+from project.api.schema.out.general.errors_info_general import ErrorsInfoGeneralSO
 
 api_router = APIRouter()
 
@@ -19,11 +17,7 @@ api_router = APIRouter()
 async def _(
         *,
         request: fastapi.requests.Request,
-        response: fastapi.responses.Response,
-        api_auth_data: APIAuthData = fastapi.Depends(api_auth(
-            validate_api_key_func=correct_api_keys_from_settings__is_api_key_correct_func(),
-            require_correct_api_key=True,
-        ))
+        response: fastapi.responses.Response
 ):
     return ErrorsInfoGeneralSO(
         api_error_codes=APIErrorCodes.values_list(),

arpakitlib/_arpakit_project_template_v_4/project/api/router/client/main_router.py

@@ -0,0 +1,3 @@
+from fastapi import APIRouter
+
+main_client_api_router = APIRouter()

arpakitlib/_arpakit_project_template_v_4/project/api/router/client/now_utc_datetime.py

@@ -0,0 +1,22 @@
+import fastapi
+from fastapi import APIRouter
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+from project.api.schema.out.common.datetime_ import DatetimeCommonSO
+from project.api.schema.out.general.error import ErrorGeneralSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Now UTC datetime",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=DatetimeCommonSO | ErrorGeneralSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response
+):
+    return DatetimeCommonSO.from_datetime(datetime_=now_utc_dt())

arpakitlib/_arpakit_project_template_v_4/project/api/router/general/healthcheck.py

@@ -0,0 +1,21 @@
+import fastapi
+from fastapi import APIRouter
+from project.api.schema.out.common.error import ErrorCommonSO
+
+from project.api.schema.out.general.healthcheck import HealthcheckGeneralSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    name="Healthcheck",
+    status_code=fastapi.status.HTTP_200_OK,
+    response_model=HealthcheckGeneralSO | ErrorCommonSO,
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response
+):
+    return HealthcheckGeneralSO(is_ok=True)

arpakitlib/_arpakit_project_template_v_4/project/api/router/general/main_router.py

@@ -0,0 +1,10 @@
+from fastapi import APIRouter
+
+from project.api.router.general import healthcheck
+
+main_general_api_router = APIRouter()
+
+main_general_api_router.include_router(
+    router=healthcheck.api_router,
+    prefix="/healthcheck"
+)