arpakitlib 1.7.257__py3-none-any.whl → 1.8.1__py3-none-any.whl

arpakitlib/{_arpakit_project_template → _arpakit_project_template_v_1}/README.md

@@ -1,4 +1,4 @@
-# {{PROJECT_NAME}}
+# ...
 
 ## ❤️ Made by ARPAKIT Company ❤️
 

arpakitlib/{_arpakit_project_template → _arpakit_project_template_v_1}/alembic/env.py

@@ -5,8 +5,8 @@ from sqlalchemy import engine_from_config
 from sqlalchemy import pool
 
 from arpakitlib.ar_type_util import raise_for_type
-from src.core.settings import get_cached_settings
-from src.sqlalchemy_db.util import get_base_dbm
+from core.settings import get_cached_settings
+from sqlalchemy_db.sqlalchemy_model import get_simple_dbm
 
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
@@ -24,7 +24,7 @@ if config.config_file_name is not None:
 # for 'autogenerate' support
 # from myapp import mymodel
 # target_metadata = mymodel.Base.metadata
-target_metadata = get_base_dbm().metadata
+target_metadata = get_simple_dbm().metadata
 
 
 # other values from the config, defined by the needs of env.py,

arpakitlib/_arpakit_project_template_v_1/api/asgi.py

@@ -0,0 +1,3 @@
+from api.create_api_app import create_api_app
+
+app = create_api_app()

arpakitlib/_arpakit_project_template_v_1/api/auth.py

@@ -0,0 +1,235 @@
+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 api.const import APIErrorCodes
+from api.exception import APIException
+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):
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+
+    require_api_key_string: bool = False
+    require_token_string: bool = False
+
+    require_correct_api_key: bool = False
+    require_correct_token: bool = False
+
+    token_string: str | None = None
+    api_key_string: str | None = None
+
+    is_token_correct: bool | None = None
+    is_api_key_correct: bool | None = None
+
+
+def api_auth(
+        *,
+        require_api_key_string: bool = False,
+        require_token_string: bool = False,
+        validate_api_key_func: Callable | None = None,
+        validate_token_func: Callable | None = None,
+        correct_api_keys: str | list[str] | None = None,
+        correct_tokens: str | list[str] | None = None,
+        require_correct_api_key: bool = False,
+        require_correct_token: bool = False
+) -> 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 validate_api_key_func is None and correct_api_keys is not None:
+        validate_api_key_func = lambda *args, **kwargs_: kwargs_["api_auth_data"].api_key_string in correct_api_keys
+
+    if isinstance(correct_tokens, str):
+        correct_tokens = [correct_tokens]
+    if correct_tokens is not None:
+        raise_for_type(correct_tokens, list)
+
+    if validate_token_func is None and correct_tokens is not None:
+        validate_token_func = lambda *args, **kwargs_: kwargs_["api_auth_data"].token_string in correct_tokens
+
+    if require_correct_api_key is True:
+        require_api_key_string = True
+
+    if require_correct_token is True:
+        require_token_string = True
+
+    async def func(
+            *,
+            ac: fastapi.security.HTTPAuthorizationCredentials | None = fastapi.Security(
+                fastapi.security.HTTPBearer(auto_error=False)
+            ),
+            api_key_string: str | None = Security(
+                APIKeyHeader(name="apikey", auto_error=False)
+            ),
+            request: fastapi.requests.Request
+    ) -> APIAuthData:
+
+        api_auth_data = APIAuthData(
+            require_api_key_string=require_api_key_string,
+            require_token_string=require_token_string,
+            require_correct_api_key=require_correct_api_key,
+            require_correct_token=require_correct_token
+        )
+
+        # 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"]
+
+        # parse token
+
+        api_auth_data.token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
+
+        if not api_auth_data.token_string and "token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["token"]
+
+        if not api_auth_data.token_string and "user_token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["user_token"]
+        if not api_auth_data.token_string and "user-token" in request.headers.keys():
+            api_auth_data.token_string = request.headers["user-token"]
+        if not api_auth_data.token_string and "usertoken" in request.headers.keys():
+            api_auth_data.token_string = request.headers["usertoken"]
+
+        if not api_auth_data.token_string and "token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["token"]
+
+        if not api_auth_data.token_string and "user_token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["user_token"]
+        if not api_auth_data.token_string and "user-token" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["user-token"]
+        if not api_auth_data.token_string and "usertoken" in request.query_params.keys():
+            api_auth_data.token_string = request.query_params["usertoken"]
+
+        if api_auth_data.token_string:
+            api_auth_data.token_string = api_auth_data.token_string.strip()
+        if not api_auth_data.token_string:
+            api_auth_data.token_string = None
+
+        # 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=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+            )
+
+        # require_token_string
+
+        if require_token_string and not api_auth_data.token_string:
+            raise APIException(
+                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())
+            )
+
+        # validate_api_key_func
+
+        if validate_api_key_func is not None:
+            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,
+                    request=request
+                )
+            elif is_sync_function(validate_api_key_func):
+                api_auth_data.is_api_key_correct = validate_api_key_func()
+            else:
+                raise TypeError("unknown validate_api_key_func type")
+
+        # validate_token_func
+
+        if validate_token_func is not None:
+            if is_async_callable(validate_token_func):
+                api_auth_data.is_token_correct = await validate_token_func(
+                    api_auth_data=api_auth_data,
+                    request=request
+                )
+            elif is_sync_function(validate_token_func):
+                api_auth_data.is_token_correct = validate_token_func()
+            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=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump()),
+                )
+
+        # require_correct_token
+
+        if require_correct_token:
+            if not api_auth_data.is_token_correct:
+                raise APIException(
+                    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())
+                )
+
+        return api_auth_data
+
+    return func
+
+
+def correct_api_keys_from_settings__validate_api_key_func() -> Callable:
+    async def func(
+            *,
+            api_auth_data: APIAuthData,
+            request: fastapi.requests.Request,
+    ):
+        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 get_cached_settings().api_correct_api_keys:
+            return False
+        return True
+
+    return func
+
+
+def correct_tokens_from_settings__validate_api_key_func() -> Callable:
+    async def func(
+            *,
+            api_auth_data: APIAuthData,
+            request: fastapi.requests.Request,
+    ):
+        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 get_cached_settings().api_correct_tokens:
+            return False
+        return True
+
+    return func

arpakitlib/_arpakit_project_template_v_1/api/const.py

@@ -0,0 +1,18 @@
+from arpakitlib.ar_enumeration_util import Enumeration
+
+
+class APIErrorCodes(Enumeration):
+    cannot_authorize = "CANNOT_AUTHORIZE"
+    unknown_error = "UNKNOWN_ERROR"
+    error_in_request = "ERROR_IN_REQUEST"
+    not_found = "NOT_FOUND"
+
+
+class APIErrorSpecificationCodes(Enumeration):
+    pass
+
+
+if __name__ == '__main__':
+    print(APIErrorCodes.str_for_print())
+    print()
+    print(APIErrorSpecificationCodes.str_for_print())

arpakitlib/_arpakit_project_template_v_1/api/create_api_app.py

@@ -0,0 +1,71 @@
+import logging
+import os
+
+from fastapi import FastAPI
+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 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(*, prefix: str = "/api") -> FastAPI:
+    setup_logging()
+
+    _logger.info("start")
+
+    api_app = FastAPI(
+        title=get_cached_settings().project_name,
+        description=get_cached_settings().project_name,
+        docs_url=None,
+        redoc_url=None,
+        openapi_url="/openapi",
+        on_startup=get_api_startup_events(),
+        on_shutdown=get_api_shutdown_events(),
+        contact={
+            "name": "ARPAKIT Company",
+            "url": "https://arpakit.com/",
+            "email": "support@arpakit.com",
+        },
+    )
+
+    api_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    add_local_openapi_ui_to_app(app=api_app)
+
+    add_exception_handler_to_app(app=api_app)
+
+    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 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")
+
+    return api_app

arpakitlib/_arpakit_project_template_v_1/api/event.py

@@ -0,0 +1,74 @@
+import logging
+from typing import Callable
+
+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__)
+
+
+# STARTUP API EVENTS
+
+
+async def async_api_startup_event():
+    _logger.info("start")
+
+    if get_cached_media_file_storage_in_dir() is not None:
+        get_cached_media_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_dump_file_storage_in_dir() is not None:
+        get_cached_dump_file_storage_in_dir().init()
+
+    if (
+            get_cached_sqlalchemy_db() is not None
+            and get_cached_settings().api_init_sqlalchemy_db
+    ):
+        get_cached_sqlalchemy_db().init()
+
+    if (
+            get_cached_json_db() is not None
+            and get_cached_settings().api_init_json_db
+    ):
+        get_cached_json_db().init()
+
+    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_settings().api_start_scheduled_operation_creator_worker:
+        _ = safe_run_worker_in_background(
+            worker=create_scheduled_operation_creator_worker(),
+            mode=SafeRunInBackgroundModes.async_task
+        )
+
+    _logger.info("finish")
+
+
+def get_api_startup_events() -> list[Callable]:
+    res = [async_api_startup_event]
+    return res
+
+
+# SHUTDOWN API EVENTS
+
+
+async def async_api_shutdown_event():
+    _logger.info("start")
+    _logger.info("finish")
+
+
+def get_api_shutdown_events() -> list[Callable]:
+    res = [async_api_shutdown_event]
+    return res

arpakitlib/_arpakit_project_template_v_1/api/exception.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import fastapi.security
+
+from api.const import APIErrorCodes
+from api.schema.common.out import ErrorCommonSO
+
+
+class APIException(fastapi.exceptions.HTTPException):
+    def __init__(
+            self,
+            *,
+            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,
+            error_data: dict[str, Any] | None = None
+    ):
+        self.status_code = status_code
+        self.error_code = error_code
+        self.error_specification_code = error_specification_code
+        self.error_description = error_description
+        if error_data is None:
+            error_data = {}
+        self.error_data = error_data
+
+        self.error_common_so = ErrorCommonSO(
+            has_error=True,
+            error_code=self.error_code,
+            error_specification_code=self.error_specification_code,
+            error_description=self.error_description,
+            error_data=self.error_data
+        )
+
+        super().__init__(
+            status_code=self.status_code,
+            detail=self.error_common_so.model_dump(mode="json")
+        )