arpakitlib 1.8.14__py3-none-any.whl → 1.8.16__py3-none-any.whl

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

@@ -0,0 +1,23 @@
+from fastapi import APIRouter
+
+from project.api.router.admin.main_router import main_admin_api_router
+from project.api.router.client.main_router import main_client_api_router
+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"]
+)
+main_api_router.include_router(
+    prefix="/client",
+    router=main_client_api_router,
+    tags=["Client"]
+)
+main_api_router.include_router(
+    prefix="/admin",
+    router=main_admin_api_router,
+    tags=["Admin"]
+)

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

@@ -0,0 +1,10 @@
+import datetime as dt
+
+from project.api.schema.common import BaseSO
+
+
+class SimpleDBMAdminCommonSO(BaseSO):
+    id: int
+    long_id: str
+    slug: str | None
+    creation_dt: dt.datetime

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/admin/operation.py

@@ -0,0 +1,23 @@
+from __future__ import annotations
+
+import datetime as dt
+from typing import Any
+
+from project.api.schema.out.admin.common import SimpleDBMAdminCommonSO
+from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM
+
+
+class OperationAdminSO(SimpleDBMAdminCommonSO):
+    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) -> OperationAdminSO:
+        return cls.model_validate(operation_dbm.simple_dict_with_sd_properties())

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/admin/story_log.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from typing import Any
+
+from project.api.schema.out.admin.common import SimpleDBMAdminCommonSO
+from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
+
+
+class StoryLogAdminSO(SimpleDBMAdminCommonSO):
+    level: str
+    type: str | None
+    title: str | None
+    data: dict[str, Any]
+
+    @classmethod
+    def from_story_log_dbm(cls, *, story_log_dbm: StoryLogDBM) -> StoryLogAdminSO:
+        return cls.model_validate(story_log_dbm.simple_dict_with_sd_properties())

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

@@ -0,0 +1,10 @@
+import datetime as dt
+
+from project.api.schema.common import BaseSO
+
+
+class SimpleDBMClientCommonSO(BaseSO):
+    id: int
+    long_id: str
+    slug: str | None
+    creation_dt: dt.datetime

arpakitlib/{_arpakit_project_template_v_2/project/api/schema/common/out.py → _arpakit_project_template_v_4/project/api/schema/out/common/datetime_.py}

@@ -1,22 +1,9 @@
 import datetime as dt
-from typing import Any
 
-from project.api.schema.base_schema import BaseSO
+from project.api.schema.common 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):
+class DatetimeCommonSO(BaseSO):
     date: dt.date
     datetime: dt.datetime | None = None
     year: int
@@ -49,7 +36,3 @@ class DatetimeCommonSO(BaseCommonSO):
             month=date_.month,
             day=date_.day
         )
-
-
-class RawDataCommonSO(BaseCommonSO):
-    data: dict[str, Any] = {}

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

@@ -0,0 +1,7 @@
+from typing import Any
+
+from project.api.schema.common import BaseSO
+
+
+class RawDataCommonSO(BaseSO):
+    data: dict[str, Any] = {}

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

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

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/general/error.py

@@ -0,0 +1,11 @@
+from typing import Any
+
+from project.api.schema.common import BaseSO
+
+
+class ErrorGeneralSO(BaseSO):
+    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] = {}

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/general/errors_info_general.py

@@ -0,0 +1,6 @@
+from project.api.schema.common import BaseSO
+
+
+class ErrorsInfoGeneralSO(BaseSO):
+    api_error_codes: list[str] = []
+    api_error_specification_codes: list[str] = []

arpakitlib/_arpakit_project_template_v_4/project/api/schema/out/general/healthcheck.py

@@ -0,0 +1,5 @@
+from project.api.schema.common import BaseSO
+
+
+class HealthcheckGeneralSO(BaseSO):
+    is_ok: bool = True

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/core/const.py

@@ -3,7 +3,7 @@ import os
 import pathlib
 
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_json_util import transfer_data_to_json_str
 
 
 class ProjectPaths(Enumeration):
@@ -25,7 +25,7 @@ class ProjectPaths(Enumeration):
 
 
 def __example():
-    print(safely_transfer_obj_to_json_str(ProjectPaths.key_to_value()))
+    print(transfer_data_to_json_str(ProjectPaths.key_to_value()))
 
 
 async def __async_example():

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/core/settings.py

@@ -6,44 +6,23 @@ import pytz
 from pydantic import field_validator
 from pydantic_core.core_schema import ValidationInfo
 
-from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_json_util import transfer_data_to_json_str
 from arpakitlib.ar_settings_util import SimpleSettings
 from arpakitlib.ar_sqlalchemy_util import generate_sqlalchemy_url
+from arpakitlib.ar_type_util import raise_for_type
 from project.core.const import ProjectPaths
 
 
-class ModeTypes(Enumeration):
-    not_prod: str = "not_prod"
-    prod: str = "prod"
-
-
 class Settings(SimpleSettings):
-    mode_type: str = ModeTypes.not_prod
-
-    @field_validator("mode_type")
-    @classmethod
-    def validate_mode_type(cls, v: Any, validation_info: ValidationInfo, **kwargs):
-        if v is None:
-            v = ModeTypes.not_prod
-        ModeTypes.parse_and_validate_values(v.lower().strip())
-        return v
-
-    @property
-    def is_mode_type_not_prod(self) -> bool:
-        return self.mode_type == ModeTypes.not_prod
-
-    def raise_if_mode_type_not_prod(self):
-        if self.is_mode_type_not_prod:
-            raise ValueError(f"mode type = {self.mode_type}")
+    prod_mode: bool = False
 
-    @property
-    def is_mode_type_prod(self) -> bool:
-        return self.mode_type == ModeTypes.prod
+    def raise_if_prod_mode(self):
+        if self.prod_mode:
+            raise ValueError(f"self.prod_mode")
 
-    def raise_if_mode_type_prod(self):
-        if self.is_mode_type_prod:
-            raise ValueError(f"mode type = {self.mode_type}")
+    def raise_if_not_prod_mode(self):
+        if not self.prod_mode:
+            raise ValueError(f"not self.prod_mode")
 
     project_name: str | None = "project"
 
@@ -105,10 +84,10 @@ class Settings(SimpleSettings):
 
     api_init_json_db: bool = False
 
-    api_correct_api_keys: list[str] | None = ["1"]
+    api_api_keys: list[str] | None = ["1"]
 
-    @field_validator("api_correct_api_keys", mode="before")
-    def validate_api_correct_api_keys(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
+    @field_validator("api_api_keys", mode="before")
+    def validate_api_api_keys(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
         if isinstance(v, str):
             v = [v]
         if isinstance(v, int):
@@ -119,10 +98,10 @@ class Settings(SimpleSettings):
                     v[i] = str(v_)
         return v
 
-    api_correct_tokens: list[str] | None = ["1"]
+    api_user_tokens: list[str] | None = ["1"]
 
-    @field_validator("api_correct_tokens", mode="before")
-    def validate_api_correct_tokens(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
+    @field_validator("api_user_tokens", mode="before")
+    def validate_api_tokens(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
         if isinstance(v, str):
             v = [v]
         if isinstance(v, int):
@@ -139,11 +118,25 @@ class Settings(SimpleSettings):
 
     api_start_scheduled_operation_creator_worker: bool = False
 
-    api_story_log__api_func_before_in_exception_handler: bool = False
+    api_create_story_log_func_before_in_api_exception_handler: bool = False
 
     sqladmin_secret_key: str | None = "85a9583cb91c4de7a78d7eb1e5306a04418c9c43014c447ea8ec8dd5deb4cf71"
 
-    sqladmin_correct_passwords: list[str] | None = ["1"]
+    sqladmin_auth_keys: list[str] | None = ["1"]
+
+    @field_validator("sqladmin_auth_keys", mode="before")
+    def validate_sqladmin_auth_keys(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
+        if isinstance(v, str):
+            v = [v]
+        if isinstance(v, int):
+            v = [str(v)]
+        if isinstance(v, list):
+            for i, v_ in enumerate(v):
+                if isinstance(v_, int):
+                    v[i] = str(v_)
+        return v
+
+    sqladmin_port: int | None = 8081
 
     tg_bot_token: str | None = None
 
@@ -165,6 +158,16 @@ class Settings(SimpleSettings):
 
     tg_bot_webhook_enabled: bool = False
 
+    tg_bot_drop_pending_updates: bool = True
+
+    tg_bot_start_operation_executor_worker: bool = False
+
+    tg_bot_start_scheduled_operation_creator_worker: bool = False
+
+    tg_bot_command_passwd: str | None = "1"
+
+    tg_bot_admin_tg_ids: list[int] = [269870432]
+
     var_dirpath: str | None = os.path.join(ProjectPaths.base_dirpath, "var")
 
     log_filepath: str | None = os.path.join(var_dirpath, "story.log")
@@ -181,6 +184,7 @@ class Settings(SimpleSettings):
 
     @property
     def local_timezone_as_pytz(self) -> Any:
+        raise_for_type(self.local_timezone, str)
         return pytz.timezone(self.local_timezone)
 
 
@@ -192,4 +196,4 @@ def get_cached_settings() -> Settings:
 
 
 if __name__ == '__main__':
-    print(safely_transfer_obj_to_json_str(get_cached_settings().model_dump(mode="json")))
+    print(transfer_data_to_json_str(get_cached_settings().model_dump(mode="json")))

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqladmin_/admin_auth.py

@@ -3,6 +3,7 @@ import logging
 import fastapi
 from sqladmin.authentication import AuthenticationBackend
 
+from arpakitlib.ar_str_util import make_none_if_blank
 from project.core.settings import get_cached_settings
 
 
@@ -14,33 +15,36 @@ class SQLAdminAuth(AuthenticationBackend):
     async def login(self, request: fastapi.Request) -> bool:
         form = await request.form()
 
-        username, password = form.get("username"), form.get("password")
+        username = form.get("username")
         if username:
             username = username.strip()
+        username = make_none_if_blank(username)
+
+        password = form.get("password")
         if password:
             password = password.strip()
+        password = make_none_if_blank(password)
 
-        if get_cached_settings().sqladmin_correct_passwords is not None:
+        if get_cached_settings().sqladmin_auth_keys is not None:
             if (
                     (
                             is_username_correct := (
                                     username is not None
-                                    and username in get_cached_settings().sqladmin_correct_passwords
+                                    and username in get_cached_settings().sqladmin_auth_keys
                             )
                     )
                     or
                     (
                             is_password_correct := (
                                     password is not None
-                                    and password in get_cached_settings().sqladmin_correct_passwords
+                                    and password in get_cached_settings().sqladmin_auth_keys
                             )
                     )
             ):
                 if is_username_correct is True:
-                    request.session.update({"sqladmin_key": username})
+                    request.session.update({"sqladmin_auth_key": username})
                 elif is_password_correct is True:
-                    request.session.update({"sqladmin_key": password})
-
+                    request.session.update({"sqladmin_auth_key": password})
                 return True
 
         return False
@@ -50,12 +54,13 @@ class SQLAdminAuth(AuthenticationBackend):
         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()
+        sqladmin_auth_key = request.session.get("sqladmin_auth_key")
+        if sqladmin_auth_key:
+            sqladmin_auth_key = sqladmin_auth_key.strip()
+        sqladmin_auth_key = make_none_if_blank(sqladmin_auth_key)
 
-        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:
+        if get_cached_settings().sqladmin_auth_keys is not None:
+            if sqladmin_auth_key is not None and sqladmin_auth_key in get_cached_settings().sqladmin_auth_keys:
                 return True
 
         return False

arpakitlib/_arpakit_project_template_v_4/project/sqladmin_/asgi.py

@@ -0,0 +1,3 @@
+from project.sqladmin_.create_sqladmin_app import create_sqladmin_app
+
+app = create_sqladmin_app()

arpakitlib/_arpakit_project_template_v_4/project/sqladmin_/create_sqladmin_app.py

@@ -0,0 +1,49 @@
+import logging
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+from project.sqladmin_.add_admin_in_app import add_sqladmin_in_app
+from project.sqladmin_.event import get_sqladmin_startup_events, get_sqladmin_shutdown_events
+
+_logger = logging.getLogger(__name__)
+
+
+def create_sqladmin_app(*, prefix: str = "/sqladmin") -> FastAPI:
+    setup_logging()
+
+    _logger.info("start")
+
+    sqladmin_app = FastAPI(
+        title=get_cached_settings().project_name,
+        description=get_cached_settings().project_name,
+        docs_url=None,
+        redoc_url=None,
+        openapi_url=None,
+        on_startup=get_sqladmin_startup_events(),
+        on_shutdown=get_sqladmin_shutdown_events(),
+        contact={
+            "name": "ARPAKIT Company",
+            "url": "https://arpakit.com/",
+            "email": "support@arpakit.com",
+        },
+    )
+
+    sqladmin_app.add_middleware(
+        CORSMiddleware,
+        allow_origins=["*"],
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    add_sqladmin_in_app(
+        app=sqladmin_app,
+        base_url=prefix
+    )
+
+    _logger.info("finish")
+
+    return sqladmin_app

arpakitlib/_arpakit_project_template_v_4/project/sqladmin_/event.py

@@ -0,0 +1,40 @@
+import logging
+from typing import Callable
+
+from project.core.settings import get_cached_settings
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+
+_logger = logging.getLogger(__name__)
+
+
+# STARTUP API EVENTS
+
+
+async def async_sqladmin_startup_event():
+    _logger.info("start")
+
+    if (
+            get_cached_sqlalchemy_db() is not None
+            and get_cached_settings().api_init_sqlalchemy_db
+    ):
+        get_cached_sqlalchemy_db().init()
+
+    _logger.info("finish")
+
+
+def get_sqladmin_startup_events() -> list[Callable]:
+    res = [async_sqladmin_startup_event]
+    return res
+
+
+# SHUTDOWN API EVENTS
+
+
+async def async_sqladmin_shutdown_event():
+    _logger.info("start")
+    _logger.info("finish")
+
+
+def get_sqladmin_shutdown_events() -> list[Callable]:
+    res = [async_sqladmin_shutdown_event]
+    return res

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqladmin_/model_view/operation.py

@@ -1,4 +1,4 @@
-from project.sqladmin_.model_view.common import SimpleMV
+from project.sqladmin_.model_view import SimpleMV
 from project.sqlalchemy_db_.sqlalchemy_model import OperationDBM
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqladmin_/model_view/story_log.py

@@ -1,4 +1,4 @@
-from project.sqladmin_.model_view.common import SimpleMV
+from project.sqladmin_.model_view import SimpleMV
 from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqlalchemy_db_/sqlalchemy_model/__init__.py

@@ -1,7 +1,11 @@
 from arpakitlib.ar_sqlalchemy_util import get_string_info_from_declarative_base
+
+from project.sqlalchemy_db_.sqlalchemy_model.api_key import ApiKeyDBM
 from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
 from project.sqlalchemy_db_.sqlalchemy_model.operation import OperationDBM
 from project.sqlalchemy_db_.sqlalchemy_model.story_log import StoryLogDBM
+from project.sqlalchemy_db_.sqlalchemy_model.user import UserDBM
+from project.sqlalchemy_db_.sqlalchemy_model.user_token import UserTokenDBM
 
 if __name__ == '__main__':
     print(get_string_info_from_declarative_base(SimpleDBM))

arpakitlib/_arpakit_project_template_v_4/project/sqlalchemy_db_/sqlalchemy_model/api_key.py

@@ -0,0 +1,44 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+import sqlalchemy
+from sqlalchemy.orm import Mapped, mapped_column
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+from project.sqlalchemy_db_.sqlalchemy_model.common import SimpleDBM
+
+if TYPE_CHECKING:
+    pass
+
+
+def generate_default_api_key_value() -> str:
+    return (
+        f"apikey"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
+class ApiKeyDBM(SimpleDBM):
+    __tablename__ = "api_key"
+
+    title: Mapped[str | None] = mapped_column(
+        sqlalchemy.TEXT,
+        insert_default=None,
+        nullable=True
+    )
+    value: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT,
+        unique=True,
+        insert_default=generate_default_api_key_value,
+        nullable=False
+    )
+    is_enabled: Mapped[bool] = mapped_column(
+        sqlalchemy.Boolean,
+        index=True,
+        insert_default=True,
+        server_default="true",
+        nullable=False
+    )

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqlalchemy_db_/sqlalchemy_model/common.py

@@ -1,4 +1,5 @@
 from datetime import datetime
+from typing import Any
 
 import sqlalchemy
 from sqlalchemy import func
@@ -13,18 +14,40 @@ class SimpleDBM(BaseDBM):
     __abstract__ = True
 
     id: Mapped[int] = mapped_column(
-        sqlalchemy.INTEGER, primary_key=True, autoincrement=True, sort_order=-13, nullable=False
+        sqlalchemy.INTEGER,
+        primary_key=True,
+        autoincrement=True,
+        sort_order=-103,
+        nullable=False
     )
     long_id: Mapped[str] = mapped_column(
-        sqlalchemy.TEXT, insert_default=generate_default_long_id, server_default=func.gen_random_uuid(),
-        unique=True, sort_order=-12, nullable=False
+        sqlalchemy.TEXT,
+        insert_default=generate_default_long_id,
+        server_default=func.gen_random_uuid(),
+        unique=True,
+        sort_order=-102,
+        nullable=False
     )
     slug: Mapped[str | None] = mapped_column(
-        sqlalchemy.TEXT, unique=True, sort_order=-11, nullable=True
+        sqlalchemy.TEXT,
+        unique=True,
+        sort_order=-101,
+        nullable=True
     )
     creation_dt: Mapped[datetime] = mapped_column(
-        sqlalchemy.TIMESTAMP(timezone=True), insert_default=now_utc_dt, server_default=func.now(),
-        index=True, sort_order=-10, nullable=False
+        sqlalchemy.TIMESTAMP(timezone=True),
+        insert_default=now_utc_dt,
+        server_default=func.now(),
+        index=True,
+        sort_order=-100,
+        nullable=False
+    )
+    extra_data: Mapped[dict[str, Any] | None] = mapped_column(
+        sqlalchemy.JSON,
+        index=False,
+        nullable=True,
+        insert_default=None,
+        sort_order=1000,
     )
 
     def __repr__(self) -> str:

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/sqlalchemy_db_/sqlalchemy_model/story_log.py

@@ -23,7 +23,8 @@ class StoryLogDBM(SimpleDBM):
 
     class Types(Enumeration):
         error_in_execute_operation = "error_in_execute_operation"
-        error_in_api_route = "error_in_api_route"
+        error_in_api = "error_in_api"
+        error_in_tg_bot = "error_in_tg_bot"
 
     level: Mapped[str] = mapped_column(
         sqlalchemy.TEXT, insert_default=Levels.info, server_default=Levels.info, index=True, nullable=False