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

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_1.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_2.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_3.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_4.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_5.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_6.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/sandbox/sandbox_7.py

@@ -0,0 +1,14 @@
+import asyncio
+
+
+def __sandbox():
+    pass
+
+
+async def __async_sandbox():
+    pass
+
+
+if __name__ == '__main__':
+    __sandbox()
+    asyncio.run(__async_sandbox())

arpakitlib/_arpakit_project_template_v_1/site/router/main_router.py

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

arpakitlib/_arpakit_project_template_v_1/sqladmin_/add_admin_in_app.py

@@ -0,0 +1,24 @@
+from fastapi import FastAPI
+from sqladmin import Admin
+
+from core.settings import get_cached_settings
+from sqladmin_.admin_auth import SQLAdminAuth
+from sqladmin_.model_view import get_simple_mv
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
+
+
+def add_sqladmin_in_app(*, app: FastAPI, base_url: str = "sqladmin") -> FastAPI:
+    authentication_backend = SQLAdminAuth()
+
+    admin = Admin(
+        app=app,
+        engine=get_cached_sqlalchemy_db().engine,
+        base_url=base_url,
+        authentication_backend=authentication_backend,
+        title=get_cached_settings().project_name
+    )
+
+    for model_view in get_simple_mv().__subclasses__():
+        admin.add_model_view(model_view)
+
+    return app

arpakitlib/_arpakit_project_template_v_1/sqladmin_/admin_auth.py

@@ -0,0 +1,54 @@
+import logging
+
+import fastapi
+from sqladmin.authentication import AuthenticationBackend
+
+from 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 None:
+            return False
+        if (
+                (username is not None and username in get_cached_settings().sqladmin_correct_passwords)
+                or
+                (password is not None and password in get_cached_settings().sqladmin_correct_passwords)
+        ):
+            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:
+        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 None:
+            return False
+        if (
+                (username is not None and username in get_cached_settings().sqladmin_correct_passwords)
+                or
+                (password is not None and password in get_cached_settings().sqladmin_correct_passwords)
+        ):
+            return True
+
+        return False

arpakitlib/_arpakit_project_template_v_1/sqladmin_/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_v_1/sqlalchemy_db/sqlalchemy_db.py

@@ -0,0 +1,22 @@
+from functools import lru_cache
+
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDb
+from core.settings import get_cached_settings
+from sqlalchemy_db.sqlalchemy_model import get_simple_dbm
+
+
+def create_sqlalchemy_db() -> SQLAlchemyDb | None:
+    if not get_cached_settings().sqlalchemy_sync_db_url or not get_cached_settings().sqlalchemy_async_db_url:
+        return None
+
+    return SQLAlchemyDb(
+        sync_db_url=get_cached_settings().sqlalchemy_sync_db_url,
+        async_db_url=get_cached_settings().sqlalchemy_async_db_url,
+        db_echo=get_cached_settings().sqlalchemy_db_echo,
+        base_dbm=get_simple_dbm()
+    )
+
+
+@lru_cache()
+def get_cached_sqlalchemy_db() -> SQLAlchemyDb | None:
+    return create_sqlalchemy_db()

arpakitlib/_arpakit_project_template_v_1/sqlalchemy_db/sqlalchemy_model.py

@@ -0,0 +1,129 @@
+from datetime import datetime, timedelta
+from typing import Any
+
+import sqlalchemy
+from sqlalchemy import func
+from sqlalchemy.dialects import postgresql
+from sqlalchemy.orm import mapped_column, Mapped
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_sqlalchemy_util import get_string_info_from_declarative_base, BaseDBM
+from sqlalchemy_db.util import generate_default_long_id
+
+
+class SimpleDBM(BaseDBM):
+    __abstract__ = True
+
+    id: Mapped[int] = mapped_column(
+        sqlalchemy.INTEGER, primary_key=True, autoincrement=True, sort_order=-3, 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=-2, nullable=False
+    )
+    creation_dt: Mapped[datetime] = mapped_column(
+        sqlalchemy.TIMESTAMP(timezone=True), insert_default=now_utc_dt, server_default=func.now(),
+        index=True, sort_order=-1, nullable=False
+    )
+
+    def __repr__(self):
+        return f"{self.__class__.__name__.removesuffix('DBM')} (id={self.id})"
+
+
+class StoryLogDBM(SimpleDBM):
+    __tablename__ = "story_log"
+
+    class Levels(Enumeration):
+        info = "info"
+        warning = "warning"
+        error = "error"
+
+    class Types(Enumeration):
+        error_in_execute_operation = "error_in_execute_operation"
+        error_in_api_route = "error_in_api_route"
+
+    level: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT, insert_default=Levels.info, server_default=Levels.info, index=True, nullable=False
+    )
+    type: Mapped[str | None] = mapped_column(sqlalchemy.TEXT, index=True, default=None, nullable=True)
+    title: Mapped[str | None] = mapped_column(sqlalchemy.TEXT, index=True, default=None, nullable=True)
+    data: Mapped[dict[str, Any]] = mapped_column(
+        postgresql.JSON, insert_default={}, server_default="{}", nullable=False
+    )
+
+
+class OperationDBM(SimpleDBM):
+    __tablename__ = "operation"
+
+    class Statuses(Enumeration):
+        waiting_for_execution = "waiting_for_execution"
+        executing = "executing"
+        executed_without_error = "executed_without_error"
+        executed_with_error = "executed_with_error"
+
+    class Types(Enumeration):
+        healthcheck_ = "healthcheck"
+        raise_fake_error_ = "raise_fake_error_"
+
+    status: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT, index=True, insert_default=Statuses.waiting_for_execution,
+        server_default=Statuses.waiting_for_execution, nullable=False
+    )
+    type: Mapped[str] = mapped_column(
+        sqlalchemy.TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
+    )
+    execution_start_dt: Mapped[datetime | None] = mapped_column(sqlalchemy.TIMESTAMP(timezone=True), nullable=True)
+    execution_finish_dt: Mapped[datetime | None] = mapped_column(sqlalchemy.TIMESTAMP(timezone=True), nullable=True)
+    input_data: Mapped[dict[str, Any]] = mapped_column(
+        postgresql.JSON,
+        insert_default={},
+        server_default="{}",
+        nullable=False
+    )
+    output_data: Mapped[dict[str, Any]] = mapped_column(
+        postgresql.JSON, insert_default={}, server_default="{}", nullable=False
+    )
+    error_data: Mapped[dict[str, Any]] = mapped_column(
+        postgresql.JSON, insert_default={}, server_default="{}", nullable=False
+    )
+
+    def raise_if_executed_with_error(self):
+        if self.status == self.Statuses.executed_with_error:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) executed with error, error_data={self.error_data}"
+            )
+
+    def raise_if_error_data(self):
+        if self.error_data:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) has error_data, error_data={self.error_data}"
+            )
+
+    @property
+    def duration(self) -> timedelta | None:
+        if self.execution_start_dt is None or self.execution_finish_dt is None:
+            return None
+        return self.execution_finish_dt - self.execution_start_dt
+
+    @property
+    def duration_total_seconds(self) -> float | None:
+        if self.duration is None:
+            return None
+        return self.duration.total_seconds()
+
+    @property
+    def sdp_duration_total_seconds(self) -> float | None:
+        return self.duration_total_seconds
+
+
+def get_simple_dbm() -> type[SimpleDBM]:
+    return SimpleDBM
+
+
+def import_sqlalchemy_models():
+    pass
+
+
+if __name__ == '__main__':
+    print(get_string_info_from_declarative_base(SimpleDBM))

arpakitlib/_arpakit_project_template_v_1/sqlalchemy_db/util.py

@@ -0,0 +1,28 @@
+from uuid import uuid4
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+
+
+def generate_api_key() -> str:
+    return (
+        f"apikey"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
+def generate_default_long_id():
+    return (
+        f"longid"
+        f"{str(uuid4()).replace('-', '')}"
+        f"{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
+def __example():
+    print(generate_api_key())
+    print(generate_default_long_id())
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/{_arpakit_project_template/src/sandbox/sandbox_3.py → _arpakit_project_template_v_1/test_data/make_test_data_1.py}

@@ -1,15 +1,20 @@
 import asyncio
 
 
-# ...
+def make_test_data_1():
+    pass
 
 
-def __example():
+async def async_make_test_data_1():
     pass
 
 
+def __example():
+    make_test_data_1()
+
+
 async def __async_example():
-    pass
+    await async_make_test_data_1()
 
 
 if __name__ == '__main__':

arpakitlib/{_arpakit_project_template/src/sandbox/sandbox_4.py → _arpakit_project_template_v_1/test_data/make_test_data_2.py}

@@ -1,15 +1,20 @@
 import asyncio
 
 
-# ...
+def make_test_data_2():
+    pass
 
 
-def __example():
+async def async_make_test_data_2():
     pass
 
 
+def __example():
+    make_test_data_2()
+
+
 async def __async_example():
-    pass
+    await async_make_test_data_2()
 
 
 if __name__ == '__main__':

arpakitlib/{_arpakit_project_template/src/sandbox/sandbox_1.py → _arpakit_project_template_v_1/test_data/make_test_data_3.py}

@@ -1,15 +1,20 @@
 import asyncio
 
 
-# ...
+def make_test_data_3():
+    pass
 
 
-def __example():
+async def async_make_test_data_3():
     pass
 
 
+def __example():
+    make_test_data_3()
+
+
 async def __async_example():
-    pass
+    await async_make_test_data_3()
 
 
 if __name__ == '__main__':

arpakitlib/{_arpakit_project_template/src/sandbox/sandbox_2.py → _arpakit_project_template_v_1/test_data/make_test_data_4.py}

@@ -1,15 +1,20 @@
 import asyncio
 
 
-# ...
+def make_test_data_4():
+    pass
 
 
-def __example():
+async def async_make_test_data_4():
     pass
 
 
+def __example():
+    make_test_data_4()
+
+
 async def __async_example():
-    pass
+    await async_make_test_data_4()
 
 
 if __name__ == '__main__':

arpakitlib/_arpakit_project_template_v_1/test_data/make_test_data_5.py

@@ -0,0 +1,22 @@
+import asyncio
+
+
+def make_test_data_5():
+    pass
+
+
+async def async_make_test_data_5():
+    pass
+
+
+def __example():
+    make_test_data_5()
+
+
+async def __async_example():
+    await async_make_test_data_5()
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/_arpakit_project_template_v_1/tg_bot/blank/blank.py

@@ -0,0 +1,5 @@
+from arpakitlib.ar_blank_util import BaseBlank
+
+
+class TgBotBlank(BaseBlank):
+    pass

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v_1}/tg_bot/blank/util.py

@@ -1,6 +1,6 @@
 from functools import lru_cache
 
-from src.tg_bot.blank.blank import TgBotBlank
+from tg_bot.blank.blank import TgBotBlank
 
 
 def get_create_tg_bot_blank() -> TgBotBlank:

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v_1}/tg_bot/const.py

@@ -1,11 +1,14 @@
 from arpakitlib.ar_enumeration_util import Enumeration
 
 
-class TgBotPublicCommands(Enumeration):
+class TgBotCommands(Enumeration):
+    # public
+    healthcheck = "healthcheck"
+    arpakitlib = "arpakitlib"
     start = "start"
+    about = "about"
 
-
-class TgBotPrivateCommands(Enumeration):
+    # private
     init_db = "init_db"
     reinit_db = "reinit_db"
     drop_db = "drop_db"

arpakitlib/_arpakit_project_template_v_1/tg_bot/event.py

@@ -0,0 +1,51 @@
+import logging
+from typing import Callable
+
+from aiogram import Dispatcher
+
+from tg_bot.transmitted_tg_data import get_cached_transmitted_tg_bot_data
+
+_logger = logging.getLogger(__name__)
+
+
+async def on_startup():
+    _logger.info("start")
+
+    if get_cached_transmitted_tg_bot_data().media_file_storage_in_dir is not None:
+        get_cached_transmitted_tg_bot_data().media_file_storage_in_dir.init()
+
+    if get_cached_transmitted_tg_bot_data().cache_file_storage_in_dir is not None:
+        get_cached_transmitted_tg_bot_data().cache_file_storage_in_dir.init()
+
+    if get_cached_transmitted_tg_bot_data().dump_file_storage_in_dir is not None:
+        get_cached_transmitted_tg_bot_data().dump_file_storage_in_dir.init()
+
+    if get_cached_transmitted_tg_bot_data().settings.api_init_sqlalchemy_db:
+        get_cached_transmitted_tg_bot_data().sqlalchemy_db.init()
+
+    if get_cached_transmitted_tg_bot_data().settings.api_init_json_db:
+        get_cached_transmitted_tg_bot_data().json_db.init()
+
+    _logger.info("finish")
+
+
+async def on_shutdown(*args, **kwargs):
+    _logger.info("start")
+    _logger.info("finish")
+
+
+def get_tg_bot_startup_events() -> list[Callable]:
+    res = [on_startup]
+    return res
+
+
+def get_tg_bot_shutdown_events() -> list[Callable]:
+    res = [on_shutdown]
+    return res
+
+
+def add_events_to_tg_bot_dispatcher(*, tg_bot_dispatcher: Dispatcher):
+    for tg_bot_event in get_tg_bot_startup_events():
+        tg_bot_dispatcher.startup.register(tg_bot_event)
+    for tg_bot_event in get_tg_bot_shutdown_events():
+        tg_bot_dispatcher.shutdown.register(tg_bot_event)

arpakitlib/{_arpakit_project_template/src → _arpakit_project_template_v_1}/tg_bot/filter/not_prod_mode.py

@@ -1,6 +1,6 @@
 from aiogram.filters import Filter
 
-from src.core.settings import get_cached_settings
+from core.settings import get_cached_settings
 
 
 class NotProdModeFilter(Filter):