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

arpakitlib/{_arpakit_project_template → _arpakit_project_template_v1}/README.md

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

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v1}/admin1/add_admin_in_app.py

@@ -1,19 +1,16 @@
-import importlib
-from contextlib import suppress
-
 from fastapi import FastAPI
 from sqladmin import Admin
 
-from arpakitlib.ar_sqladmin_util import SimpleModelView
-from src.admin1.admin_auth import AdminAuth
-from src.api.transmitted_api_data import TransmittedAPIData
-from src.core.settings import get_cached_settings
+from admin1.admin_auth import Admin1Auth
+from admin1.model_view import get_simple_mv
+from api.transmitted_api_data import TransmittedAPIData
+from core.settings import get_cached_settings
 
 
 def add_admin1_in_app(*, app: FastAPI) -> FastAPI:
     transmitted_api_data: TransmittedAPIData = app.state.transmitted_api_data
 
-    authentication_backend = AdminAuth()
+    authentication_backend = Admin1Auth()
 
     admin = Admin(
         app=app,
@@ -23,10 +20,7 @@ def add_admin1_in_app(*, app: FastAPI) -> FastAPI:
         title=get_cached_settings().project_name
     )
 
-    with suppress(Exception):
-        importlib.import_module("src.admin1.model_view")
-
-    for model_view in SimpleModelView.all_subclasses:
+    for model_view in get_simple_mv().__subclasses__():
         admin.add_model_view(model_view)
 
     return app

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v1}/admin1/admin_auth.py

@@ -3,19 +3,17 @@ import logging
 from sqladmin.authentication import AuthenticationBackend
 from starlette.requests import Request
 
-from src.core.settings import get_cached_settings
+from core.settings import get_cached_settings
 
 
-class AdminAuth(AuthenticationBackend):
+class Admin1Auth(AuthenticationBackend):
     def __init__(self):
         self._logger = logging.getLogger(self.__class__.__name__)
         super().__init__(secret_key=get_cached_settings().admin1_secret_key)
 
     async def login(self, request: Request) -> bool:
-        # ...
         # form = await request.form()
         # request.session.update(...)
-        # ...
         return True
 
     async def logout(self, request: Request) -> bool:
@@ -23,7 +21,5 @@ class AdminAuth(AuthenticationBackend):
         return True
 
     async def authenticate(self, request: Request) -> bool:
-        # ...
         # request.session.get("...")
-        # ...
         return True

arpakitlib/_arpakit_project_template_v1/admin1/model_view.py

@@ -0,0 +1,95 @@
+from sqladmin import ModelView
+
+from arpakitlib.ar_sqladmin_util import get_string_info_from_model_view
+from sqlalchemy_db.sqlalchemy_model import StoryLogDBM, OperationDBM
+
+
+class SimpleMV(ModelView):
+    can_create = True
+    can_edit = True
+    can_delete = True
+    can_view_details = True
+    can_export = True
+    page_size = 50
+    page_size_options = [50, 100, 200]
+    save_as = True
+    save_as_continue = True
+    export_types = ["xlsx", "csv", "json"]
+
+
+class StoryLogMV(SimpleMV, model=StoryLogDBM):
+    name = "StoryLog"
+    name_plural = "StoryLogs"
+    column_list = [
+        StoryLogDBM.id,
+        StoryLogDBM.long_id,
+        StoryLogDBM.creation_dt,
+        StoryLogDBM.level,
+        StoryLogDBM.type,
+        StoryLogDBM.title,
+        StoryLogDBM.data
+    ]
+    form_columns = [
+        StoryLogDBM.level,
+        StoryLogDBM.type,
+        StoryLogDBM.title,
+        StoryLogDBM.data
+    ]
+    column_default_sort = [
+        (StoryLogDBM.creation_dt, True)
+    ]
+    column_searchable_list = [
+        StoryLogDBM.id,
+        StoryLogDBM.long_id,
+        StoryLogDBM.level,
+        StoryLogDBM.type,
+        StoryLogDBM.title,
+        StoryLogDBM.data
+    ]
+
+
+class OperationMV(SimpleMV, model=OperationDBM):
+    name = "Operation"
+    name_plural = "Operations"
+    column_list = [
+        OperationDBM.id,
+        OperationDBM.long_id,
+        OperationDBM.creation_dt,
+        OperationDBM.status,
+        OperationDBM.type,
+        OperationDBM.execution_start_dt,
+        OperationDBM.execution_finish_dt,
+        OperationDBM.input_data,
+        OperationDBM.output_data,
+        OperationDBM.error_data
+    ]
+    form_columns = [
+        OperationDBM.status,
+        OperationDBM.type,
+        OperationDBM.execution_start_dt,
+        OperationDBM.execution_finish_dt,
+        OperationDBM.input_data,
+        OperationDBM.output_data,
+        OperationDBM.error_data
+    ]
+    column_default_sort = [
+        (OperationDBM.creation_dt, True)
+    ]
+    column_searchable_list = [
+        OperationDBM.id,
+        OperationDBM.long_id,
+        OperationDBM.status,
+        OperationDBM.type,
+    ]
+
+
+def get_simple_mv() -> type[SimpleMV]:
+    return SimpleMV
+
+
+def import_sqladmin_model_views():
+    pass
+
+
+if __name__ == '__main__':
+    print(get_string_info_from_model_view(class_=SimpleMV))

arpakitlib/{_arpakit_project_template → _arpakit_project_template_v1}/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_v1/api/asgi.py

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

arpakitlib/_arpakit_project_template_v1/api/auth.py

@@ -0,0 +1,244 @@
+from typing import Callable
+
+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.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
+
+
+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: starlette.requests.Request,
+            transmitted_api_data: TransmittedAPIData = Depends(get_transmitted_api_data)
+    ) -> 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=starlette.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=starlette.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,
+                    transmitted_api_data=transmitted_api_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,
+                    transmitted_api_data=transmitted_api_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=starlette.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=starlette.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_key_from_settings__validate_api_key_func() -> Callable:
+    async def func(
+            *,
+            api_auth_data: APIAuthData,
+            transmitted_api_data: TransmittedAPIData,
+            request: starlette.requests.Request,
+    ):
+        if transmitted_api_data.settings.api_correct_api_keys is None:
+            return True
+        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:
+            return False
+        return True
+
+    return func
+
+
+def correct_token_from_settings__validate_api_key_func() -> Callable:
+    async def func(
+            *,
+            api_auth_data: APIAuthData,
+            transmitted_api_data: TransmittedAPIData,
+            request: starlette.requests.Request,
+    ):
+        if transmitted_api_data.settings.api_correct_tokens is None:
+            return True
+        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:
+            return False
+        return True
+
+    return func

arpakitlib/_arpakit_project_template_v1/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_v1/api/create_api_app.py

@@ -0,0 +1,72 @@
+import logging
+import os
+
+from fastapi import FastAPI
+from starlette.middleware.cors import CORSMiddleware
+from starlette.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.util import setup_logging
+
+_logger = logging.getLogger(__name__)
+
+
+def create_api_app() -> 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,
+        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.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=["*"],
+        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(router=main_api_router)
+
+    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)
+
+    _logger.info("finish")
+
+    return api_app

arpakitlib/_arpakit_project_template_v1/api/event.py

@@ -0,0 +1,69 @@
+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 operation_execution.operation_executor_worker import create_operation_executor_worker
+from operation_execution.scheduled_operation_creator_worker import create_scheduled_operation_creator_worker
+
+_logger = logging.getLogger(__name__)
+
+
+# STARTUP API EVENTS
+
+
+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_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_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_transmitted_api_data().sqlalchemy_db is not None
+            and get_cached_transmitted_api_data().settings.api_init_sqlalchemy_db
+    ):
+        get_cached_transmitted_api_data().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_transmitted_api_data().json_db.init()
+
+    if get_cached_transmitted_api_data().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:
+        _ = 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_v1/api/exception.py

@@ -0,0 +1,39 @@
+from typing import Any
+
+import fastapi.security
+import starlette.status
+
+from api.const import APIErrorCodes
+from api.schema.common.out import ErrorCommonSO
+
+
+class APIException(fastapi.exceptions.HTTPException):
+    def __init__(
+            self,
+            *,
+            status_code: int = starlette.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")
+        )