arpakitlib 1.8.12__tar.gz → 1.8.14__tar.gz

{arpakitlib-1.8.12 → arpakitlib-1.8.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.8.12
+Version: 1.8.14
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company
@@ -34,6 +34,7 @@ Requires-Dist: jupyter (>=1.1.1,<2.0.0)
 Requires-Dist: matplotlib (>=3.10.0,<4.0.0)
 Requires-Dist: openai (>=1.59.9,<2.0.0)
 Requires-Dist: openpyxl (>=3.1.5,<4.0.0)
+Requires-Dist: orjson (>=3.10.15,<4.0.0)
 Requires-Dist: pandas (>=2.2.3,<3.0.0)
 Requires-Dist: paramiko (>=3.5.0,<4.0.0)
 Requires-Dist: pika (>=1.3.2,<2.0.0)

{arpakitlib-1.8.12 → arpakitlib-1.8.14}/arpakitlib/_arpakit_project_template_v_2/project/api/auth.py

@@ -20,34 +20,38 @@ 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_user_token_string: bool = False
 
     require_correct_api_key: bool = False
-    require_correct_token: bool = False
+    require_correct_user_token: bool = False
 
-    token_string: str | None = None
+    require_mode_type: str | None = None
+    require_not_mode_type: str | None = None
+
+    current_mode_type: str | None = None
+
+    user_token_string: str | None = None
     api_key_string: str | None = None
 
     is_token_correct: bool | None = None
     is_api_key_correct: bool | None = None
 
-    require_mode_type: str | None = None
-    require_not_mode_type: str | None = None
-    current_mode_type: str | 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_user_token_string: bool = False,
+
         require_correct_api_key: bool = False,
-        require_correct_token: bool = False,
+        require_correct_user_token: bool = False,
+
         require_mode_type: str | None = None,
-        require_not_mode_type: str | None = None
+        require_not_mode_type: str | None = None,
+
+        validate_api_key_func: Callable | None = None,
+        validate_user_token_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]
@@ -55,21 +59,25 @@ def api_auth(
         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
+        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 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 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 validate_user_token_func is None and correct_user_tokens is not None:
+        validate_user_token_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_token is True:
-        require_token_string = True
+    if require_correct_user_token is True:
+        require_user_token_string = True
 
     async def func(
             *,
@@ -84,9 +92,9 @@ def api_auth(
 
         api_auth_data = APIAuthData(
             require_api_key_string=require_api_key_string,
-            require_token_string=require_token_string,
+            require_user_token_string=require_user_token_string,
             require_correct_api_key=require_correct_api_key,
-            require_correct_token=require_correct_token,
+            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
@@ -110,34 +118,39 @@ def api_auth(
         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
+        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
 
-        api_auth_data.token_string = ac.credentials if ac and ac.credentials and ac.credentials.strip() else None
+        # parse user token
 
-        if not api_auth_data.token_string and "token" in request.headers.keys():
-            api_auth_data.token_string = request.headers["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.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.user_token_string and "token" in request.headers.keys():
+            api_auth_data.user_token_string = request.headers["token"]
 
-        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.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.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 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 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
+        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
 
@@ -170,7 +183,7 @@ def api_auth(
 
         # require_token_string
 
-        if require_token_string and not api_auth_data.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,
@@ -192,14 +205,14 @@ def api_auth(
 
         # 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(
+        if validate_user_token_func is not None:
+            if is_async_callable(validate_user_token_func):
+                api_auth_data.is_token_correct = await validate_user_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()
+            elif is_sync_function(validate_user_token_func):
+                api_auth_data.is_token_correct = validate_user_token_func()
             else:
                 raise TypeError("unknown validate_token_func type")
 
@@ -216,7 +229,7 @@ def api_auth(
 
         # require_correct_token
 
-        if require_correct_token:
+        if require_correct_user_token:
             if not api_auth_data.is_token_correct:
                 raise APIException(
                     status_code=fastapi.status.HTTP_401_UNAUTHORIZED,
@@ -230,8 +243,8 @@ def api_auth(
     return func
 
 
-def correct_api_keys_from_settings__validate_api_key_func() -> Callable:
-    async def 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,
@@ -244,21 +257,21 @@ def correct_api_keys_from_settings__validate_api_key_func() -> Callable:
             return False
         return True
 
-    return func
+    return async_func
 
 
-def correct_tokens_from_settings__validate_api_key_func() -> Callable:
-    async def 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:
             return False
-        if api_auth_data.token_string is None:
+        if api_auth_data.user_token_string is None:
             return False
-        if api_auth_data.token_string.strip() not in get_cached_settings().api_correct_tokens:
+        if api_auth_data.user_token_string.strip() not in get_cached_settings().api_correct_tokens:
             return False
         return True
 
-    return func
+    return async_func

{arpakitlib-1.8.12 → arpakitlib-1.8.14}/arpakitlib/_arpakit_project_template_v_2/project/api/response.py

@@ -3,7 +3,7 @@ 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.v1.out import BaseSO
+from project.api.schema.base_schema import BaseSO
 
 
 class APIJSONResponse(fastapi.responses.JSONResponse):

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/general/get_auth_data.py

@@ -0,0 +1,31 @@
+import fastapi.requests
+from fastapi import APIRouter
+
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
+from project.api.auth import APIAuthData, api_auth, correct_tokens_from_settings__is_user_token_correct_func, \
+    correct_api_keys_from_settings__is_api_key_correct_func
+from project.api.schema.common.out import ErrorCommonSO, RawDataCommonSO
+from project.core.settings import ModeTypes
+
+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(
+            validate_api_key_func=correct_api_keys_from_settings__is_api_key_correct_func(),
+            validate_user_token_func=correct_tokens_from_settings__is_user_token_correct_func(),
+            require_correct_api_key=False,
+            require_correct_user_token=False,
+            require_not_mode_type=ModeTypes.prod
+        ))
+):
+    return RawDataCommonSO(data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump()))

{arpakitlib-1.8.12/arpakitlib/_arpakit_project_template_v_2/project/api/router/v1 → arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/general}/get_errors_info.py

@@ -1,9 +1,11 @@
 import fastapi.requests
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter
 
-from project.api.auth import APIAuthData, api_auth, correct_api_keys_from_settings__validate_api_key_func
+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, ErrorsInfoCommonSO
+from project.api.schema.common.out import ErrorCommonSO
+from project.api.schema.general.out import ErrorsInfoGeneralSO
 
 api_router = APIRouter()
 
@@ -12,22 +14,18 @@ api_router = APIRouter()
     "",
     name="Get errors info",
     status_code=fastapi.status.HTTP_200_OK,
-    response_model=ErrorsInfoCommonSO | ErrorCommonSO,
+    response_model=ErrorsInfoGeneralSO | ErrorCommonSO,
 )
 async def _(
         *,
         request: fastapi.requests.Request,
         response: fastapi.responses.Response,
-        api_auth_data: APIAuthData = Depends(api_auth(
-            require_api_key_string=True,
-            require_token_string=False,
-            validate_api_key_func=correct_api_keys_from_settings__validate_api_key_func(),
-            validate_token_func=None,
+        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,
-            require_correct_token=False,
         ))
 ):
-    return ErrorsInfoCommonSO(
+    return ErrorsInfoGeneralSO(
         api_error_codes=APIErrorCodes.values_list(),
         api_error_specification_codes=APIErrorSpecificationCodes.values_list()
     )

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/general/healthcheck.py

@@ -0,0 +1,26 @@
+import fastapi
+from fastapi import APIRouter
+
+from project.api.auth import APIAuthData, api_auth, correct_api_keys_from_settings__is_api_key_correct_func
+from project.api.schema.common.out import ErrorCommonSO
+from project.api.schema.general.out 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,
+        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,
+        ))
+):
+    return HealthcheckGeneralSO(is_ok=True)

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/general/main_router.py

@@ -0,0 +1,24 @@
+from fastapi import APIRouter
+
+from project.api.router.general import get_errors_info, healthcheck, now_utc_datetime, get_auth_data
+from project.core.settings import get_cached_settings
+
+main_general_api_router = APIRouter()
+
+main_general_api_router.include_router(
+    router=healthcheck.api_router,
+    prefix="/healthcheck"
+)
+main_general_api_router.include_router(
+    router=get_errors_info.api_router,
+    prefix="/get_errors_info"
+)
+main_general_api_router.include_router(
+    router=now_utc_datetime.api_router,
+    prefix="/now_utc_datetime"
+)
+if not get_cached_settings().is_mode_type_prod:
+    main_general_api_router.include_router(
+        router=get_auth_data.api_router,
+        prefix="/get_auth_data"
+    )

{arpakitlib-1.8.12/arpakitlib/_arpakit_project_template_v_2/project/api/router/v1 → arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/general}/now_utc_datetime.py

@@ -2,6 +2,7 @@ import fastapi
 from fastapi import APIRouter
 
 from arpakitlib.ar_datetime_util import now_utc_dt
+from project.api.auth import APIAuthData, api_auth, correct_api_keys_from_settings__is_api_key_correct_func
 from project.api.schema.common.out import ErrorCommonSO, DatetimeCommonSO
 
 api_router = APIRouter()
@@ -17,5 +18,9 @@ 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,
+        ))
 ):
     return DatetimeCommonSO.from_datetime(datetime_=now_utc_dt())

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/router/main_router.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+
+from project.api.router.general.main_router import main_general_api_router
+
+main_api_router = APIRouter()
+
+main_api_router.include_router(
+    prefix="/general",
+    router=main_general_api_router,
+    tags=["General"]
+)

{arpakitlib-1.8.12 → arpakitlib-1.8.14}/arpakitlib/_arpakit_project_template_v_2/project/api/schema/common/out.py

@@ -53,8 +53,3 @@ class DatetimeCommonSO(BaseCommonSO):
 
 class RawDataCommonSO(BaseCommonSO):
     data: dict[str, Any] = {}
-
-
-class ErrorsInfoCommonSO(BaseCommonSO):
-    api_error_codes: list[str] = []
-    api_error_specification_codes: list[str] = []

{arpakitlib-1.8.12/arpakitlib/_arpakit_project_template_v_2/project/api/schema/v1 → arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/schema/example}/in_.py

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

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/schema/example/out.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+from project.api.schema.base_schema import BaseSO
+from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM, OperationDBM
+
+
+class BaseExampleSO(BaseSO):
+    pass
+
+
+class SimpleDBMExampleSO(BaseExampleSO):
+    id: int
+    long_id: str
+    slug: str | None
+    creation_dt: dt.datetime
+
+
+class StoryLogExampleSO(SimpleDBMExampleSO):
+    level: str
+    type: str | None
+    title: str | None
+    data: dict[str, Any]
+
+    @classmethod
+    def from_story_log_dbm(cls, *, story_log_dbm: StoryLogDBM) -> StoryLogExampleSO:
+        return cls.model_validate(story_log_dbm.simple_dict_with_sd_properties())
+
+
+class OperationExampleSO(SimpleDBMExampleSO):
+    execution_start_dt: dt.datetime | None
+    execution_finish_dt: dt.datetime | None
+    status: str
+    type: str
+    title: str | None
+    input_data: dict[str, Any]
+    output_data: dict[str, Any]
+    error_data: dict[str, Any]
+    duration_total_seconds: float | None
+
+    @classmethod
+    def from_operation_dbm(cls, *, operation_dbm: OperationDBM) -> OperationExampleSO:
+        return cls.model_validate(operation_dbm.simple_dict_with_sd_properties())

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/schema/general/in_.py

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

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/api/schema/general/out.py

@@ -0,0 +1,14 @@
+from project.api.schema.base_schema import BaseSO
+
+
+class BaseGeneralSO(BaseSO):
+    pass
+
+
+class HealthcheckGeneralSO(BaseGeneralSO):
+    is_ok: bool = True
+
+
+class ErrorsInfoGeneralSO(BaseGeneralSO):
+    api_error_codes: list[str] = []
+    api_error_specification_codes: list[str] = []

{arpakitlib-1.8.12 → arpakitlib-1.8.14}/arpakitlib/_arpakit_project_template_v_2/project/sqladmin_/add_admin_in_app.py

@@ -3,7 +3,7 @@ from sqladmin import Admin
 
 from project.core.settings import get_cached_settings
 from project.sqladmin_.admin_auth import SQLAdminAuth
-from project.sqladmin_.model_view import get_simple_mv
+from project.sqladmin_.model_view import SimpleMV
 from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 
 
@@ -18,7 +18,7 @@ def add_sqladmin_in_app(*, app: FastAPI, base_url: str = "/sqladmin") -> FastAPI
         title=get_cached_settings().project_name
     )
 
-    for model_view in get_simple_mv().__subclasses__():
+    for model_view in SimpleMV.__subclasses__():
         admin.add_model_view(model_view)
 
     return app

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/sqladmin_/admin_auth.py

@@ -0,0 +1,61 @@
+import logging
+
+import fastapi
+from sqladmin.authentication import AuthenticationBackend
+
+from project.core.settings import get_cached_settings
+
+
+class SQLAdminAuth(AuthenticationBackend):
+    def __init__(self):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        super().__init__(secret_key=get_cached_settings().sqladmin_secret_key)
+
+    async def login(self, request: fastapi.Request) -> bool:
+        form = await request.form()
+
+        username, password = form.get("username"), form.get("password")
+        if username:
+            username = username.strip()
+        if password:
+            password = password.strip()
+
+        if get_cached_settings().sqladmin_correct_passwords is not None:
+            if (
+                    (
+                            is_username_correct := (
+                                    username is not None
+                                    and username in get_cached_settings().sqladmin_correct_passwords
+                            )
+                    )
+                    or
+                    (
+                            is_password_correct := (
+                                    password is not None
+                                    and password in get_cached_settings().sqladmin_correct_passwords
+                            )
+                    )
+            ):
+                if is_username_correct is True:
+                    request.session.update({"sqladmin_key": username})
+                elif is_password_correct is True:
+                    request.session.update({"sqladmin_key": password})
+
+                return True
+
+        return False
+
+    async def logout(self, request: fastapi.Request) -> bool:
+        request.session.clear()
+        return True
+
+    async def authenticate(self, request: fastapi.Request) -> bool:
+        sqladmin_key = request.session.get("sqladmin_key")
+        if sqladmin_key:
+            sqladmin_key = sqladmin_key.strip()
+
+        if get_cached_settings().sqladmin_correct_passwords is not None:
+            if sqladmin_key is not None and sqladmin_key in get_cached_settings().sqladmin_correct_passwords:
+                return True
+
+        return False

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/sqladmin_/model_view/__init__.py

@@ -0,0 +1,3 @@
+from project.sqladmin_.model_view.common import SimpleMV
+from project.sqladmin_.model_view.operation import OperationMV
+from project.sqladmin_.model_view.story_log import StoryLogMV

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/sqladmin_/model_view/common.py

@@ -0,0 +1,24 @@
+from sqladmin import ModelView
+
+
+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"]
+
+
+def get_simple_mv_class() -> type[SimpleMV]:
+    from project.sqladmin_.model_view import SimpleMV
+    return SimpleMV
+
+
+if __name__ == '__main__':
+    for model_view in get_simple_mv_class().__subclasses__():
+        print(model_view)

arpakitlib-1.8.14/arpakitlib/_arpakit_project_template_v_2/project/sqladmin_/model_view/operation.py

@@ -0,0 +1,43 @@
+from project.sqladmin_.model_view.common import SimpleMV
+from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM
+
+
+class OperationMV(SimpleMV, model=OperationDBM):
+    name = "Operation"
+    name_plural = "Operations"
+    column_list = [
+        OperationDBM.id,
+        OperationDBM.long_id,
+        OperationDBM.slug,
+        OperationDBM.creation_dt,
+        OperationDBM.status,
+        OperationDBM.type,
+        OperationDBM.title,
+        OperationDBM.execution_start_dt,
+        OperationDBM.execution_finish_dt,
+        OperationDBM.input_data,
+        OperationDBM.output_data,
+        OperationDBM.error_data
+    ]
+    form_columns = [
+        OperationDBM.slug,
+        OperationDBM.status,
+        OperationDBM.type,
+        OperationDBM.title,
+        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.slug,
+        OperationDBM.status,
+        OperationDBM.type,
+        OperationDBM.title
+    ]