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

arpakitlib/_arpakit_project_template_v1/api/exception_handler.py

@@ -0,0 +1,297 @@
+import asyncio
+import inspect
+import logging
+from contextlib import suppress
+from typing import Any, Callable
+
+import fastapi.exceptions
+import fastapi.exceptions
+import fastapi.responses
+import fastapi.security
+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
+from api.response import APIJSONResponse
+from api.schema.common.out import ErrorCommonSO
+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 core.settings import get_cached_settings
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
+from sqlalchemy_db.sqlalchemy_model import StoryLogDBM
+
+_logger = logging.getLogger(__name__)
+
+
+def create_exception_handler(
+        *,
+        funcs_before: list[Callable | None] | None = None,
+        async_funcs_after: list[Callable | None] | None = None
+) -> Callable:
+    if funcs_before is None:
+        funcs_before = []
+    funcs_before = [v for v in funcs_before if v is not None]
+
+    if async_funcs_after is None:
+        async_funcs_after = []
+    async_funcs_after = [v for v in async_funcs_after if v is not None]
+
+    async def func(
+            request: starlette.requests.Request,
+            exception: Exception
+    ) -> APIJSONResponse:
+        status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
+
+        error_common_so = ErrorCommonSO(
+            has_error=True,
+            error_code=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):
+            old_error_data = error_common_so.error_data
+            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):
+            status_code = exception.status_code
+            if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
+                error_common_so.error_code = APIErrorCodes.cannot_authorize
+            elif status_code == starlette.status.HTTP_404_NOT_FOUND:
+                error_common_so.error_code = APIErrorCodes.not_found
+            else:
+                status_code = starlette.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
+            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
+            error_common_so.error_code = APIErrorCodes.unknown_error
+
+        if error_common_so.error_code is not None:
+            error_common_so.error_code = error_common_so.error_code.upper().replace(" ", "_").strip()
+
+        if error_common_so.error_specification_code is not None:
+            error_common_so.error_specification_code = (
+                error_common_so.error_specification_code.upper().replace(" ", "_").strip()
+            )
+
+        if error_common_so.error_code == APIErrorCodes.not_found:
+            status_code = starlette.status.HTTP_404_NOT_FOUND
+
+        if error_common_so.error_code == APIErrorCodes.cannot_authorize:
+            status_code = starlette.status.HTTP_401_UNAUTHORIZED
+
+        error_common_so.error_data["status_code"] = status_code
+
+        # funcs_before
+
+        _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
+                )
+            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
+                )
+            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
+
+        for async_func_after in async_funcs_after:
+            raise_if_not_async_callable(async_func_after)
+            _ = asyncio.create_task(async_func_after(
+                request=request, status_code=status_code, error_common_so=error_common_so, exception=exception
+            ))
+
+        return APIJSONResponse(
+            content=error_common_so,
+            status_code=status_code
+        )
+
+    return func
+
+
+def logging__api_func_before_in_handle_exception(
+        *,
+        ignore_api_error_codes: list[str] | None = None,
+        ignore_status_codes: list[int] | None = None,
+        ignore_exception_types: list[type[Exception]] | None = None
+) -> Callable:
+    current_func_name = inspect.currentframe().f_code.co_name
+
+    def func(
+            *,
+            request: starlette.requests.Request,
+            status_code: int,
+            error_common_so: ErrorCommonSO,
+            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
+
+        if ignore_status_codes is not None and status_code in ignore_status_codes:
+            return error_common_so, transmitted_kwargs
+
+        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
+
+        _logger.error(safely_transfer_obj_to_json_str(error_common_so.model_dump()), exc_info=False)
+
+    return func
+
+
+def story_log__api_func_before_in_handle_exception(
+        *,
+        ignore_api_error_codes: list[str] | None = None,
+        ignore_status_codes: list[int] | None = None,
+        ignore_exception_types: list[type[Exception]] | None = None,
+) -> Callable:
+    current_func_name = inspect.currentframe().f_code.co_name
+
+    async def async_func(
+            *,
+            request: starlette.requests.Request,
+            status_code: int,
+            error_common_so: ErrorCommonSO,
+            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
+
+        if ignore_status_codes is not None and status_code in ignore_status_codes:
+            return error_common_so, transmitted_kwargs
+
+        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
+
+        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,
+                title=f"{status_code}, {type(exception)}",
+                data={
+                    "error_common_so": error_common_so.model_dump(),
+                    "traceback_str": exception_to_traceback_str(exception=exception)
+                }
+            )
+            session.add(story_log_dbm)
+            await session.commit()
+            await session.refresh(story_log_dbm)
+
+        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 async_func
+
+
+def get_exception_handler() -> Callable:
+    funcs_before = []
+    async_funcs_after = []
+
+    if get_cached_settings().api_story_log__api_func_before_in_exception_handler:
+        funcs_before.append(
+            story_log__api_func_before_in_handle_exception(
+                ignore_api_error_codes=[
+                    APIErrorCodes.cannot_authorize,
+                    APIErrorCodes.error_in_request,
+                    APIErrorCodes.not_found
+                ],
+                ignore_status_codes=[
+                    starlette.status.HTTP_401_UNAUTHORIZED,
+                    starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    starlette.status.HTTP_404_NOT_FOUND
+                ],
+                ignore_exception_types=[
+                    fastapi.exceptions.RequestValidationError
+                ],
+            )
+        )
+
+    funcs_before.append(
+        logging__api_func_before_in_handle_exception(
+            ignore_api_error_codes=[
+                APIErrorCodes.cannot_authorize,
+                APIErrorCodes.error_in_request,
+                APIErrorCodes.not_found
+            ],
+            ignore_status_codes=[
+                starlette.status.HTTP_401_UNAUTHORIZED,
+                starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                starlette.status.HTTP_404_NOT_FOUND
+            ],
+            ignore_exception_types=[
+                fastapi.exceptions.RequestValidationError
+            ],
+        )
+    )
+
+    return create_exception_handler(
+        funcs_before=funcs_before,
+        async_funcs_after=async_funcs_after
+    )
+
+
+def add_exception_handler_to_app(*, app: FastAPI) -> FastAPI:
+    exception_handler = get_exception_handler()
+
+    app.add_exception_handler(
+        exc_class_or_status_code=Exception,
+        handler=exception_handler
+    )
+    app.add_exception_handler(
+        exc_class_or_status_code=ValueError,
+        handler=exception_handler
+    )
+    app.add_exception_handler(
+        exc_class_or_status_code=fastapi.exceptions.RequestValidationError,
+        handler=exception_handler
+    )
+    app.add_exception_handler(
+        exc_class_or_status_code=starlette.exceptions.HTTPException,
+        handler=exception_handler
+    )
+
+    return app

arpakitlib/_arpakit_project_template_v1/api/openapi_ui.py

@@ -0,0 +1,28 @@
+from fastapi import FastAPI
+from fastapi.openapi.docs import get_swagger_ui_html, get_redoc_html
+
+
+def add_local_openapi_ui_to_app(
+        *,
+        app: FastAPI
+):
+    @app.get("/docs", include_in_schema=False)
+    async def custom_swagger_ui_html():
+        return get_swagger_ui_html(
+            openapi_url=app.openapi_url,
+            title=app.title,
+            swagger_js_url="/static/swagger-ui/swagger-ui-bundle.js",
+            swagger_css_url="/static/swagger-ui/swagger-ui.css",
+            swagger_favicon_url="/static/openapi-favicon.png"
+        )
+
+    @app.get("/redoc", include_in_schema=False)
+    async def custom_redoc_html():
+        return get_redoc_html(
+            openapi_url=app.openapi_url,
+            title=app.title,
+            redoc_js_url="/static/redoc/redoc.standalone.js",
+            redoc_favicon_url="/static/openapi-favicon.png"
+        )
+
+    return app

arpakitlib/_arpakit_project_template_v1/api/response.py

@@ -0,0 +1,27 @@
+import fastapi.security
+import starlette.status
+
+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):
+        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=content,
+            status_code=status_code
+        )

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v1}/api/router/main_router.py

@@ -1,10 +1,11 @@
 from fastapi import APIRouter
 
-from src.api.router.v1.main_router import main_v1_api_router
+from api.router.v1.main_router import main_v1_api_router
 
 main_api_router = APIRouter()
 
-# API Error Info
+# V1 API Router
+
 
 main_api_router.include_router(
     router=main_v1_api_router,

arpakitlib/_arpakit_project_template_v1/api/router/v1/arpakitlib_.py

@@ -0,0 +1,27 @@
+import fastapi
+import starlette.status
+from fastapi import APIRouter
+
+from api.schema.common.out import ErrorCommonSO
+from api.schema.v1.out import ARPAKITLIBInfoV1SO
+from util.read_arpakitlib_project_template_file import read_arpakitlib_project_template_file
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=ARPAKITLIBInfoV1SO | ErrorCommonSO,
+    status_code=starlette.status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    arpakitlib_project_template_data = read_arpakitlib_project_template_file()
+    return ARPAKITLIBInfoV1SO(
+        arpakitlib=True,
+        arpakitlib_project_template_version=arpakitlib_project_template_data["arpakitlib_project_template_version"],
+        data=arpakitlib_project_template_data
+    )

arpakitlib/_arpakit_project_template_v1/api/router/v1/check_auth.py

@@ -0,0 +1,30 @@
+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.schema.common.out import ErrorCommonSO, RawDataCommonSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=RawDataCommonSO | ErrorCommonSO,
+    status_code=status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+        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(),
+            require_correct_api_key=False,
+            require_correct_token=False,
+        ))
+):
+    return RawDataCommonSO(data=api_auth_data.model_dump())

arpakitlib/_arpakit_project_template_v1/api/router/v1/get_errors_info.py

@@ -0,0 +1,24 @@
+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
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=ErrorsInfoCommonSO | ErrorCommonSO,
+    status_code=status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    return ErrorsInfoCommonSO(
+        api_error_codes=APIErrorCodes.values_list(),
+        api_error_specification_codes=APIErrorSpecificationCodes.values_list()
+    )

arpakitlib/_arpakit_project_template_v1/api/router/v1/healthcheck.py

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

arpakitlib/_arpakit_project_template_v1/api/router/v1/main_router.py

@@ -0,0 +1,54 @@
+from fastapi import APIRouter
+
+from api.router.v1 import healthcheck, get_errors_info, now_utc_datetime
+from api.router.v1 import raise_fake_error, check_auth, arpakitlib_
+
+main_v1_api_router = APIRouter()
+
+# Healthcheck
+
+main_v1_api_router.include_router(
+    router=healthcheck.api_router,
+    prefix="/healthcheck",
+    tags=["Healthcheck"]
+)
+
+# arpakitlib_
+
+main_v1_api_router.include_router(
+    router=arpakitlib_.api_router,
+    prefix="/arpakitlib",
+    tags=["arpakitlib"]
+)
+
+# Get errors info
+
+main_v1_api_router.include_router(
+    router=get_errors_info.api_router,
+    prefix="/get_errors_info",
+    tags=["Errors info"]
+)
+
+# Check auth
+
+main_v1_api_router.include_router(
+    router=check_auth.api_router,
+    prefix="/check_auth",
+    tags=["Check auth"]
+)
+
+# Raise fake error
+
+main_v1_api_router.include_router(
+    router=raise_fake_error.api_router,
+    prefix="/raise_fake_error",
+    tags=["Fake error"]
+)
+
+# Healthcheck
+
+main_v1_api_router.include_router(
+    router=now_utc_datetime.api_router,
+    prefix="/now_utc_datetime",
+    tags=["Now UTC datetime"]
+)

arpakitlib/_arpakit_project_template_v1/api/router/v1/now_utc_datetime.py

@@ -0,0 +1,21 @@
+import fastapi
+import starlette.status
+from fastapi import APIRouter
+
+from api.schema.common.out import ErrorCommonSO, DatetimeCommonSO
+from arpakitlib.ar_datetime_util import now_utc_dt
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=DatetimeCommonSO | ErrorCommonSO,
+    status_code=starlette.status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    return DatetimeCommonSO.from_datetime(datetime_=now_utc_dt())

arpakitlib/_arpakit_project_template_v1/api/router/v1/raise_fake_error.py

@@ -0,0 +1,21 @@
+import fastapi
+import starlette
+from fastapi import APIRouter
+from starlette import status
+
+from api.schema.common.out import ErrorCommonSO
+
+api_router = APIRouter()
+
+
+@api_router.get(
+    "",
+    response_model=ErrorCommonSO,
+    status_code=starlette.status.HTTP_200_OK
+)
+async def _(
+        *,
+        request: fastapi.requests.Request,
+        response: fastapi.responses.Response,
+):
+    raise Exception("fake_error")

arpakitlib/_arpakit_project_template_v1/api/schema/base_schema.py

@@ -0,0 +1,26 @@
+from typing import Any
+
+from pydantic import ConfigDict, BaseModel
+
+
+class BaseSchema(BaseModel):
+    model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
+
+    @classmethod
+    def __pydantic_init_subclass__(cls, **kwargs: Any) -> None:
+        if not (
+                cls.__name__.endswith("SO")
+                or cls.__name__.endswith("SI")
+                or cls.__name__.endswith("SchemaIn")
+                or cls.__name__.endswith("SchemaOut")
+        ):
+            raise ValueError("APISchema class should ends with SO | SI | SchemaIn | SchemaOut")
+        super().__init_subclass__(**kwargs)
+
+
+class BaseSI(BaseSchema):
+    pass
+
+
+class BaseSO(BaseSchema):
+    pass

arpakitlib/_arpakit_project_template_v1/api/schema/common/in_.py

@@ -0,0 +1,5 @@
+from api.schema.base_schema import BaseSI
+
+
+class BaseCommonSI(BaseSI):
+    pass

arpakitlib/_arpakit_project_template_v1/api/schema/common/out.py

@@ -0,0 +1,60 @@
+import datetime as dt
+from typing import Any
+
+from api.schema.base_schema import BaseSO
+
+
+class BaseCommonSO(BaseSO):
+    pass
+
+
+class ErrorCommonSO(BaseCommonSO):
+    has_error: bool = True
+    error_code: str | None = None
+    error_specification_code: str | None = None
+    error_description: str | None = None
+    error_data: dict[str, Any] = {}
+
+
+class DatetimeCommonSO(BaseCommonSO):
+    date: dt.date
+    datetime: dt.datetime | None = None
+    year: int
+    month: int
+    day: int
+    hour: int | None = None
+    minute: int | None = None
+    second: int | None = None
+    microsecond: int | None = None
+
+    @classmethod
+    def from_datetime(cls, datetime_: dt.datetime):
+        return cls(
+            date=datetime_.date(),
+            datetime=datetime_,
+            year=datetime_.year,
+            month=datetime_.month,
+            day=datetime_.day,
+            hour=datetime_.hour,
+            minute=datetime_.minute,
+            second=datetime_.second,
+            microsecond=datetime_.microsecond
+        )
+
+    @classmethod
+    def from_date(cls, date_: dt.date):
+        return cls(
+            date=date_,
+            year=date_.year,
+            month=date_.month,
+            day=date_.day
+        )
+
+
+class RawDataCommonSO(BaseCommonSO):
+    data: dict[str, Any] = {}
+
+
+class ErrorsInfoCommonSO(BaseCommonSO):
+    api_error_codes: list[str] = []
+    api_error_specification_codes: list[str] = []

arpakitlib/_arpakit_project_template_v1/api/schema/v1/in_.py

@@ -0,0 +1,5 @@
+from api.schema.base_schema import BaseSI
+
+
+class BaseV1SI(BaseSI):
+    pass