arpakitlib 1.8.18__py3-none-any.whl → 1.8.20__py3-none-any.whl

arpakitlib/_arpakit_project_template_v_4/project/api/auth.py

@@ -1,353 +0,0 @@
-from typing import Callable
-
-import fastapi
-import fastapi.exceptions
-import fastapi.responses
-import fastapi.security
-import sqlalchemy
-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 arpakitlib.ar_type_util import raise_for_type
-from project.api.const import APIErrorCodes
-from project.api.exception import APIException
-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 ApiKeyDBM, UserTokenDBM
-
-
-class APIAuthData(BaseModel):
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
-
-    require_api_key_string: bool = False
-    require_user_token_string: bool = False
-
-    require_correct_api_key: bool = False
-    require_correct_user_token: bool = False
-
-    require_mode_type: str | None = None
-    require_not_mode_type: str | None = None
-
-    current_mode_type: str | None = None
-
-    api_key_string: str | None = None
-    user_token_string: str | None = None
-
-    is_api_key_correct: bool | None = None
-    is_user_token_correct: bool | None = None
-
-    api_key_dbm: ApiKeyDBM | None = None
-    user_token_dbm: UserTokenDBM | None = None
-
-
-def api_auth(
-        *,
-        require_api_key_string: bool = False,
-        require_user_token_string: bool = False,
-
-        require_correct_api_key: bool = False,
-        require_correct_user_token: bool = False,
-
-        require_mode_type: str | None = None,
-        require_not_mode_type: str | None = None,
-
-        is_api_key_correct_func: Callable | None = None,
-        is_user_token_correct_func: Callable | None = None,
-        correct_api_keys: str | list[str] | None = None,
-        correct_user_tokens: str | list[str] | None = None,
-) -> 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)
-
-    if is_api_key_correct_func is None and correct_api_keys is not None:
-        is_api_key_correct_func = (
-            lambda *args, **kwargs_: kwargs_["api_auth_data"].api_key_string in correct_api_keys
-        )
-
-    if isinstance(correct_user_tokens, str):
-        correct_user_tokens = [correct_user_tokens]
-    if correct_user_tokens is not None:
-        raise_for_type(correct_user_tokens, list)
-
-    if is_user_token_correct_func is None and correct_user_tokens is not None:
-        is_user_token_correct_func = (
-            lambda *args, **kwargs_: kwargs_["api_auth_data"].user_token_string in correct_user_tokens
-        )
-
-    if require_correct_api_key is True:
-        require_api_key_string = True
-
-    if require_correct_user_token is True:
-        require_user_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.requests.Request
-    ) -> APIAuthData:
-
-        api_auth_data = APIAuthData(
-            require_api_key_string=require_api_key_string,
-            require_user_token_string=require_user_token_string,
-            require_correct_api_key=require_correct_api_key,
-            require_correct_user_token=require_correct_user_token,
-            require_mode_type=require_mode_type,
-            require_not_mode_type=require_not_mode_type,
-            current_mode_type=get_cached_settings().mode_type
-        )
-
-        # 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
-
-        # require_mode_type
-
-        if require_mode_type is not None:
-            if get_cached_settings().mode_type != require_mode_type:
-                raise APIException(
-                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                    error_code=APIErrorCodes.cannot_authorize,
-                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
-                )
-
-        # require_not_mode_type
-
-        if require_not_mode_type is not None:
-            if get_cached_settings().mode_type == require_not_mode_type:
-                raise APIException(
-                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                    error_code=APIErrorCodes.cannot_authorize,
-                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
-                )
-
-        # require_api_key_string
-
-        if require_api_key_string and not api_auth_data.api_key_string:
-            raise APIException(
-                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                error_code=APIErrorCodes.cannot_authorize,
-                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
-            )
-
-        # require_token_string
-
-        if require_user_token_string and not api_auth_data.user_token_string:
-            raise APIException(
-                status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                error_code=APIErrorCodes.cannot_authorize,
-                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
-            )
-
-        # is_api_key_correct_func
-
-        if is_api_key_correct_func is not None:
-            if is_async_callable(is_api_key_correct_func):
-                await is_api_key_correct_func(
-                    api_auth_data=api_auth_data,
-                    request=request
-                )
-            elif is_sync_function(is_api_key_correct_func):
-                is_api_key_correct_func(
-                    api_auth_data=api_auth_data,
-                    request=request
-                )
-            else:
-                raise TypeError("unknown validate_api_key_func type")
-
-        # is_user_token_correct_func
-
-        if is_user_token_correct_func is not None:
-            if is_async_callable(is_user_token_correct_func):
-                await is_user_token_correct_func(
-                    api_auth_data=api_auth_data,
-                    request=request
-                )
-            elif is_sync_function(is_user_token_correct_func):
-                is_user_token_correct_func(
-                    api_auth_data=api_auth_data,
-                    request=request
-                )
-            else:
-                raise TypeError("unknown validate_token_func type")
-
-        # require_correct_api_key
-
-        if require_correct_api_key:
-            if not api_auth_data.is_api_key_correct:
-                raise APIException(
-                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                    error_code=APIErrorCodes.cannot_authorize,
-                    error_description="not api_auth_data.is_api_key_correct",
-                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()),
-                )
-
-        # require_correct_token
-
-        if require_correct_user_token:
-            if not api_auth_data.is_user_token_correct:
-                raise APIException(
-                    status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
-                    error_code=APIErrorCodes.cannot_authorize,
-                    error_description="not api_auth_data.is_user_token_correct",
-                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
-                )
-
-        return api_auth_data
-
-    return func
-
-
-def correct_api_keys_from_settings__is_api_key_correct_func() -> Callable:
-    async def async_func(
-            *,
-            api_auth_data: APIAuthData,
-            request: fastapi.requests.Request,
-    ):
-        if get_cached_settings().api_correct_api_keys is None:
-            api_auth_data.is_api_key_correct = False
-            return
-        if api_auth_data.api_key_string is None:
-            api_auth_data.is_api_key_correct = False
-            return
-        if api_auth_data.api_key_string.strip() not in get_cached_settings().api_correct_api_keys:
-            api_auth_data.is_api_key_correct = False
-            return
-        api_auth_data.is_api_key_correct = True
-        return
-
-    return async_func
-
-
-def correct_tokens_from_settings__is_user_token_correct_func() -> Callable:
-    async def async_func(
-            *,
-            api_auth_data: APIAuthData,
-            request: fastapi.requests.Request,
-    ):
-        if get_cached_settings().api_correct_tokens is None:
-            api_auth_data.is_api_key_correct = False
-            return
-        if api_auth_data.user_token_string is None:
-            api_auth_data.is_api_key_correct = False
-            return
-        if api_auth_data.user_token_string.strip() not in get_cached_settings().api_correct_tokens:
-            api_auth_data.is_api_key_correct = False
-            return
-        api_auth_data.is_api_key_correct = True
-        return
-
-    return async_func
-
-
-def correct_api_key_from_sqlalchemy_db__is_api_key_correct_func() -> Callable:
-    async def async_func(
-            *,
-            api_auth_data: APIAuthData,
-            request: fastapi.requests.Request,
-    ):
-        if api_auth_data.api_key_string is None:
-            api_auth_data.is_api_key_correct = False
-            return
-
-        async with get_cached_sqlalchemy_db().new_async_session() as session:
-            api_auth_data.api_key_dbm = await session.scalar(
-                sqlalchemy.select(ApiKeyDBM).where(ApiKeyDBM.value == api_auth_data.api_key_string)
-            )
-
-        if api_auth_data.api_key_dbm is None or not api_auth_data.api_key_dbm.is_enabled:
-            api_auth_data.is_api_key_correct = False
-            return
-
-        api_auth_data.is_api_key_correct = True
-        return True
-
-    return async_func
-
-
-def correct_user_token_from_sqlalchemy_db__is_user_token_correct_func(
-        *, require_user_roles: list[str] | None = None
-) -> Callable:
-    async def async_func(
-            *,
-            api_auth_data: APIAuthData,
-            request: fastapi.requests.Request,
-    ):
-        if api_auth_data.user_token_string is None:
-            api_auth_data.is_user_token_correct = False
-            return
-
-        with get_cached_sqlalchemy_db().new_session() as session:
-            api_auth_data.user_token_dbm = session.query(
-                UserTokenDBM
-            ).filter(
-                UserTokenDBM.value == api_auth_data.user_token_string
-            ).one_or_none()
-
-        if api_auth_data.user_token_dbm is None:
-            api_auth_data.is_user_token_correct = False
-            return
-        if not api_auth_data.user_token_dbm.is_enabled:
-            pass
-
-        api_auth_data.is_user_token_correct = True
-        return
-
-    return async_func

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

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

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

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

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

@@ -1,10 +0,0 @@
-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"
-)

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/common.py

@@ -1,5 +0,0 @@
-from project.api.schema.common import BaseSchema
-
-
-class BaseSO(BaseSchema):
-    pass

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/blank/client.py

@@ -1,44 +0,0 @@
-from functools import lru_cache
-
-from emoji import emojize
-
-from project.tg_bot.blank.common import SimpleBlankTgBot
-
-
-class ClientTgBotBlank(SimpleBlankTgBot):
-
-    def command_to_desc(self) -> dict[str, str]:
-        return {}
-
-    def but_hello_world(self) -> str:
-        res = "hello_world"
-        return emojize(res.strip())
-
-    def hello_world(self) -> str:
-        res = ":waving_hand: <b>Hello world</b> :waving_hand:"
-        return emojize(res.strip())
-
-    def healthcheck(self) -> str:
-        res = "healthcheck"
-        return emojize(res.strip())
-
-    def welcome(self) -> str:
-        res = ":waving_hand: <b>Welcome</b> :waving_hand:"
-        return emojize(res.strip())
-
-
-def create_client_tg_bot_blank() -> ClientTgBotBlank:
-    return ClientTgBotBlank()
-
-
-@lru_cache()
-def get_cached_client_tg_bot_blank() -> ClientTgBotBlank:
-    return ClientTgBotBlank()
-
-
-def __example():
-    print(get_cached_client_tg_bot_blank().welcome())
-
-
-if __name__ == '__main__':
-    __example()

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/error_handler.py

@@ -1,37 +0,0 @@
-import logging
-
-import aiogram
-from aiogram import Router
-
-from arpakitlib.ar_exception_util import exception_to_traceback_str
-from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
-from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
-from project.tg_bot.middleware.common import MiddlewareDataTgBot
-
-_logger = logging.getLogger(__name__)
-
-tg_bot_router = Router()
-
-
-@tg_bot_router.error()
-async def _(
-        event: aiogram.types.ErrorEvent,
-        middleware_data_tg_bot: MiddlewareDataTgBot,
-        **kwargs
-):
-    _logger.exception(event.exception)
-
-    if get_cached_sqlalchemy_db() is not None:
-        async with get_cached_sqlalchemy_db().new_async_session() as session:
-            story_log_dbm = StoryLogDBM(
-                level=StoryLogDBM.Levels.error,
-                type=StoryLogDBM.Types.error_in_tg_bot,
-                title=f"{type(event.exception)}",
-                data={
-                    "exception_str": str(event.exception),
-                    "exception_traceback_str": exception_to_traceback_str(exception=event.exception)
-                }
-            )
-        session.add(story_log_dbm)
-        await session.commit()
-        await session.refresh(story_log_dbm)

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/filter_/user_roles_has_admin.py

@@ -1,27 +0,0 @@
-import aiogram.types
-from aiogram.filters import Filter
-
-from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
-from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
-
-
-class UserRolesHasAdminTgBotFilter(Filter):
-
-    async def __call__(
-            self, update: aiogram.types.Message | aiogram.types.CallbackQuery | aiogram.types.TelegramObject, **kwargs
-    ) -> bool:
-        tg_user: None | aiogram.types.User = None
-
-        if isinstance(update, aiogram.types.Message) and update.from_user is not None:
-            tg_user = update.from_user
-        if isinstance(update, aiogram.types.CallbackQuery) and update.from_user is not None:
-            tg_user = update.from_user
-
-        if get_cached_sqlalchemy_db() is not None and tg_user is not None:
-            with get_cached_sqlalchemy_db().new_session() as session:
-                user_dbm: UserDBM | None = session.query(UserDBM).filter(UserDBM.tg_id == tg_user.id).one_or_none()
-            if user_dbm is not None:
-                if user_dbm.roles_has_admin:
-                    return True
-
-        return False

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/filter_/user_roles_has_client.py

@@ -1,27 +0,0 @@
-import aiogram.types
-from aiogram.filters import Filter
-
-from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
-from project.sqlalchemy_db_.sqlalchemy_model import UserDBM
-
-
-class UserRolesHasClientTgBotFilter(Filter):
-
-    async def __call__(
-            self, update: aiogram.types.Message | aiogram.types.CallbackQuery | aiogram.types.TelegramObject, **kwargs
-    ) -> bool:
-        tg_user: None | aiogram.types.User = None
-
-        if isinstance(update, aiogram.types.Message) and update.from_user is not None:
-            tg_user = update.from_user
-        if isinstance(update, aiogram.types.CallbackQuery) and update.from_user is not None:
-            tg_user = update.from_user
-
-        if get_cached_sqlalchemy_db() is not None and tg_user is not None:
-            with get_cached_sqlalchemy_db().new_session() as session:
-                user_dbm: UserDBM | None = session.query(UserDBM).filter(UserDBM.tg_id == tg_user.id).one_or_none()
-            if user_dbm is not None:
-                if user_dbm.roles_has_client:
-                    return True
-
-        return False

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

@@ -1,15 +0,0 @@
-from aiogram import Router
-
-from project.tg_bot.filter_.is_private_chat import IsPrivateChatTgBotFilter
-from project.tg_bot.filter_.user_roles_has_admin import UserRolesHasAdminTgBotFilter
-from project.tg_bot.router.admin import reinit_sqlalchemy_db, arpakitlib_project_template_info, raise_fake_error, me
-
-main_admin_tg_bot_router = Router()
-for observer in main_admin_tg_bot_router.observers.values():
-    observer.filter(UserRolesHasAdminTgBotFilter())
-    observer.filter(IsPrivateChatTgBotFilter())
-
-main_admin_tg_bot_router.include_router(reinit_sqlalchemy_db.tg_bot_router)
-main_admin_tg_bot_router.include_router(arpakitlib_project_template_info.tg_bot_router)
-main_admin_tg_bot_router.include_router(raise_fake_error.tg_bot_router)
-main_admin_tg_bot_router.include_router(me.tg_bot_router)

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

@@ -1,14 +0,0 @@
-from aiogram import Router
-
-from project.tg_bot.filter_.user_roles_has_client import UserRolesHasClientTgBotFilter
-from project.tg_bot.router.client import start, healthcheck, hello_world
-
-main_client_tg_bot_router = Router()
-for observer in main_client_tg_bot_router.observers.values():
-    observer.filter(UserRolesHasClientTgBotFilter())
-
-main_client_tg_bot_router.include_router(router=start.tg_bot_router)
-
-main_client_tg_bot_router.include_router(router=healthcheck.tg_bot_router)
-
-main_client_tg_bot_router.include_router(router=hello_world.tg_bot_router)

arpakitlib/_arpakit_project_template_v_4/project/tg_bot/router/main_router.py

@@ -1,13 +0,0 @@
-from aiogram import Router
-
-from project.tg_bot import error_handler
-from project.tg_bot.router.admin.main_router import main_admin_tg_bot_router
-from project.tg_bot.router.client.main_router import main_client_tg_bot_router
-
-main_tg_bot_router = Router()
-
-main_tg_bot_router.include_router(router=error_handler.tg_bot_router)
-
-main_tg_bot_router.include_router(router=main_admin_tg_bot_router)
-
-main_tg_bot_router.include_router(router=main_client_tg_bot_router)