arpakitlib 1.7.242__tar.gz → 1.7.243__tar.gz

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.7.242
+Version: 1.7.243
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/_arpakit_project_template/example.env

@@ -9,7 +9,8 @@
 # api_init_sql_db_at_start=
 # api_title=
 # api_description=
-# api_create_story_log_before_response_in_handle_exception=
+# api_logging_func_before_response=
+# api_story_log_func_before_response=
 # api_start_operation_executor_worker=
 # api_start_scheduled_operation_creator_worker=
 # api_port=

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/_arpakit_project_template/src/api/create_api_app.py

@@ -1,11 +1,7 @@
 from fastapi import FastAPI
-from starlette import status
 
-from arpakitlib.ar_fastapi_util import create_fastapi_app, \
-    create_handle_exception, create_story_log_before_response_in_handle_exception
-from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
-from arpakitlib.ar_type_util import raise_for_type
-from src.api.const import APIErrorCodes
+from arpakitlib.ar_fastapi_util import create_fastapi_app
+from src.api.create_handle_exception_ import create_handle_exception_
 from src.api.event import StartupAPIEvent, ShutdownAPIEvent
 from src.api.router.main_router import main_api_router
 from src.api.transmitted_api_data import TransmittedAPIData
@@ -31,23 +27,6 @@ def create_api_app() -> FastAPI:
         dump_file_storage_in_dir=get_cached_dump_file_storage_in_dir()
     )
 
-    funcs_before_response = []
-
-    if settings.api_create_story_log_before_response_in_handle_exception:
-        raise_for_type(sqlalchemy_db, SQLAlchemyDB)
-        funcs_before_response.append(
-            create_story_log_before_response_in_handle_exception(
-                sqlalchemy_db=sqlalchemy_db,
-                ignore_api_error_codes=[APIErrorCodes.not_found],
-                ignore_status_codes=[status.HTTP_404_NOT_FOUND]
-            )
-        )
-
-    handle_exception = create_handle_exception(
-        funcs_before_response=funcs_before_response,
-        async_funcs_after_response=[]
-    )
-
     startup_api_events = []
 
     startup_api_events.append(StartupAPIEvent(transmitted_api_data=transmitted_api_data))
@@ -56,11 +35,13 @@ def create_api_app() -> FastAPI:
 
     shutdown_api_events.append(ShutdownAPIEvent(transmitted_api_data=transmitted_api_data))
 
+    handle_exception_ = create_handle_exception_(transmitted_api_data=transmitted_api_data)
+
     api_app = create_fastapi_app(
         title=settings.api_title.strip(),
         description=settings.api_description.strip(),
         log_filepath=settings.log_filepath,
-        handle_exception_=handle_exception,
+        handle_exception_=handle_exception_,
         startup_api_events=startup_api_events,
         shutdown_api_events=shutdown_api_events,
         transmitted_api_data=transmitted_api_data,

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/api/create_handle_exception_.py

@@ -0,0 +1,59 @@
+import fastapi.exceptions
+import starlette.exceptions
+import starlette.status
+
+from arpakitlib.ar_fastapi_util import create_handle_exception, story_log_func_before_response, \
+    logging_func_before_response
+from src.api.const import APIErrorCodes
+from src.api.transmitted_api_data import TransmittedAPIData
+
+
+def create_handle_exception_(*, transmitted_api_data: TransmittedAPIData):
+    funcs_before_response = []
+
+    if transmitted_api_data.settings.api_logging_func_before_response:
+        funcs_before_response.append(
+            logging_func_before_response(
+                ignore_api_error_codes=[
+                    APIErrorCodes.cannot_authorize,
+                    APIErrorCodes.error_in_request,
+                    APIErrorCodes.not_found
+                ],
+                ignore_status_codes=[
+                    starlette.status.HTTP_401_UNAUTHORIZED,
+                    starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    starlette.status.HTTP_404_NOT_FOUND
+                ],
+                ignore_exception_types=[
+                    fastapi.exceptions.RequestValidationError
+                ],
+                need_exc_info=False
+            )
+        )
+
+    if transmitted_api_data.settings.api_story_log_func_before_response:
+        funcs_before_response.append(
+            story_log_func_before_response(
+                sqlalchemy_db=transmitted_api_data.sqlalchemy_db,
+                ignore_api_error_codes=[
+                    APIErrorCodes.cannot_authorize,
+                    APIErrorCodes.error_in_request,
+                    APIErrorCodes.not_found
+                ],
+                ignore_status_codes=[
+                    starlette.status.HTTP_401_UNAUTHORIZED,
+                    starlette.status.HTTP_422_UNPROCESSABLE_ENTITY,
+                    starlette.status.HTTP_404_NOT_FOUND
+                ],
+                ignore_exception_types=[
+                    fastapi.exceptions.RequestValidationError
+                ],
+            )
+        )
+
+    async_funcs_after_response = []
+
+    return create_handle_exception(
+        funcs_before_response=funcs_before_response,
+        async_funcs_after_response=async_funcs_after_response
+    )

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/_arpakit_project_template/src/core/settings.py

@@ -44,7 +44,9 @@ class Settings(SimpleSettings):
 
     api_description: str = f"{project_name} (arpakitlib)"
 
-    api_create_story_log_before_response_in_handle_exception: bool = True
+    api_logging_func_before_response: bool = True
+
+    api_story_log_func_before_response: bool = True
 
     api_start_operation_executor_worker: bool = False
 

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/blank/blank.py

@@ -0,0 +1,10 @@
+from emoji import emojize
+
+from arpakitlib.ar_blank_util import BaseBlank
+
+
+class TgBotBlank(BaseBlank):
+
+    def healthcheck(self) -> str:
+        res = "healthcheck"
+        return emojize(res.strip())

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/blank/util.py

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

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/const.py

@@ -0,0 +1,19 @@
+from arpakitlib.ar_enumeration_util import Enumeration
+
+
+class TgBotPublicCommands(Enumeration):
+    start = "start"
+
+
+class TgBotPrivateCommands(Enumeration):
+    init_db = "init_db"
+    reinit_db = "reinit_db"
+    drop_db = "drop_db"
+    set_tg_bot_commands = "set_tg_bot_commands"
+    raise_fake_err = "raise_fake_err"
+    log_file = "log_file"
+    clear_log_file = "clear_log_file"
+    kb_with_old_data = "kb_with_old_data"
+    kb_with_not_modified = "kb_with_not_modified"
+    kb_with_fake_error = "kb_with_fake_error"
+    kb_with_remove_message = "kb_with_remove_message"

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/router/error.py

@@ -0,0 +1,3 @@
+from aiogram import Router
+
+tg_bot_router = Router()

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/router/router.py

@@ -0,0 +1,7 @@
+from aiogram import Router
+
+from src.tg_bot.router import error
+
+main_tg_bot_router = Router()
+
+main_tg_bot_router.include_router(error.tg_bot_router)

arpakitlib-1.7.243/arpakitlib/_arpakit_project_template/src/tg_bot/start_tg_bot.py

@@ -0,0 +1,12 @@
+from src.core.settings import get_cached_settings
+from src.core.util import setup_logging
+
+
+def start_tg_bot():
+    setup_logging()
+
+    settings = get_cached_settings()
+
+
+if __name__ == '__main__':
+    start_tg_bot()

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/ar_aiogram_util.py

@@ -2,10 +2,9 @@
 
 import asyncio
 import logging
-from abc import ABC
 from typing import Optional, Any, Union, Callable, Iterable
 
-from aiogram import types, BaseMiddleware, Bot
+from aiogram import types, Bot
 from aiogram.client.default import DefaultBotProperties
 from aiogram.client.session.aiohttp import AiohttpSession
 from aiogram.enums import ChatType, ParseMode
@@ -312,12 +311,6 @@ def as_tg_command(
     return decorator
 
 
-class SimpleMiddleware(BaseMiddleware, ABC):
-    def __init__(self):
-        self.middleware_name = self.__class__.__name__
-        self._logger = logging.getLogger(self.__class__.__name__)
-
-
 class BaseTransmittedTgBotData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 

arpakitlib-1.7.243/arpakitlib/ar_blank_util.py

@@ -0,0 +1,8 @@
+# arpakit
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class BaseBlank:
+    def __init__(self, **kwargs):
+        pass

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/ar_fastapi_util.py

@@ -7,7 +7,6 @@ import datetime as dt
 import logging
 import os.path
 import pathlib
-import traceback
 from contextlib import suppress
 from typing import Any, Callable
 
@@ -27,8 +26,9 @@ from starlette.staticfiles import StaticFiles
 
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_function, is_async_object
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj
+from arpakitlib.ar_exception_util import exception_to_traceback_str
+from arpakitlib.ar_func_util import raise_if_not_async_func, is_async_object
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str_to_json_obj, safely_transfer_obj_to_json_str
 from arpakitlib.ar_logging_util import setup_normal_logging
 from arpakitlib.ar_sqlalchemy_model_util import StoryLogDBM, OperationDBM
 from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
@@ -239,19 +239,15 @@ def create_handle_exception(
             old_error_data = error_so.error_data
             error_so = exception.error_so
             error_so.error_data = combine_dicts(old_error_data, error_so.error_data)
-            _need_exc_info = False
 
         elif isinstance(exception, starlette.exceptions.HTTPException):
             status_code = exception.status_code
             if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
                 error_so.error_code = BaseAPIErrorCodes.cannot_authorize
-                _need_exc_info = False
             elif status_code == starlette.status.HTTP_404_NOT_FOUND:
                 error_so.error_code = BaseAPIErrorCodes.not_found
-                _need_exc_info = False
             else:
                 status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
-                _need_exc_info = True
             with suppress(Exception):
                 error_so.error_data["exception.detail"] = exception.detail
 
@@ -260,13 +256,10 @@ def create_handle_exception(
             error_so.error_code = BaseAPIErrorCodes.error_in_request
             with suppress(Exception):
                 error_so.error_data["exception.errors"] = str(exception.errors()) if exception.errors() else {}
-            _need_exc_info = False
 
         else:
             status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
             error_so.error_code = BaseAPIErrorCodes.unknown_error
-            _logger.exception(exception)
-            _need_exc_info = True
 
         if error_so.error_code:
             error_so.error_code = error_so.error_code.upper().replace(" ", "_").strip()
@@ -282,17 +275,12 @@ def create_handle_exception(
         if error_so.error_code == BaseAPIErrorCodes.cannot_authorize:
             status_code = status.HTTP_401_UNAUTHORIZED
 
-        if _need_exc_info:
-            _logger.error(str(exception), exc_info=exception)
-        else:
-            _logger.error(str(exception))
-
         _kwargs = {}
         for func in funcs_before_response:
             _func_data = func(
                 status_code=status_code, error_so=error_so, request=request, exception=exception, **_kwargs
             )
-            if is_async_function(_func_data):
+            if is_async_object(_func_data):
                 _func_data = await _func_data
             if _func_data is not None:
                 status_code, error_so, _kwargs = _func_data[0], _func_data[1], _func_data[2]
@@ -314,13 +302,49 @@ def create_handle_exception(
     return handle_exception
 
 
-def create_story_log_before_response_in_handle_exception(
+def logging_func_before_response(
+        *,
+        ignore_api_error_codes: list[str] | None = None,
+        ignore_status_codes: list[int] | None = None,
+        ignore_exception_types: list[type[Exception]] | None = None,
+        need_exc_info: bool = False
+):
+    def func(
+            *,
+            status_code: int,
+            error_so: ErrorSO,
+            request: starlette.requests.Request,
+            exception: Exception,
+            **kwargs
+    ) -> (int, ErrorSO, dict[str, Any]):
+        kwargs["logging_before_response_in_handle_exception"] = True
+
+        if ignore_api_error_codes and error_so.error_code in ignore_api_error_codes:
+            return status_code, error_so, kwargs
+
+        if ignore_status_codes and status_code in ignore_status_codes:
+            return status_code, error_so, kwargs
+
+        if ignore_exception_types and (
+                exception in ignore_exception_types or type(exception) in ignore_exception_types
+        ):
+            return status_code, error_so, kwargs
+
+        _logger.error(safely_transfer_obj_to_json_str(error_so.model_dump()), exc_info=need_exc_info)
+
+    return func
+
+
+def story_log_func_before_response(
         *,
         sqlalchemy_db: SQLAlchemyDB,
         ignore_api_error_codes: list[str] | None = None,
-        ignore_status_codes: list[int] | None = None
+        ignore_status_codes: list[int] | None = None,
+        ignore_exception_types: list[type[Exception]] | None = None
 ) -> Callable:
-    def func(
+    raise_for_type(sqlalchemy_db, SQLAlchemyDB)
+
+    async def async_func(
             *,
             status_code: int,
             error_so: ErrorSO,
@@ -328,31 +352,38 @@ def create_story_log_before_response_in_handle_exception(
             exception: Exception,
             **kwargs
     ) -> (int, ErrorSO, dict[str, Any]):
+        kwargs["create_story_log_before_response_in_handle_exception"] = True
+
         if ignore_api_error_codes and error_so.error_code in ignore_api_error_codes:
             return status_code, error_so, kwargs
 
         if ignore_status_codes and status_code in ignore_status_codes:
             return status_code, error_so, kwargs
 
-        sqlalchemy_db.init()
-        traceback_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
-        with sqlalchemy_db.new_session() as session:
+        if ignore_exception_types and (
+                exception in ignore_exception_types or type(exception) in ignore_exception_types
+        ):
+            return status_code, error_so, kwargs
+
+        async with sqlalchemy_db.new_async_session() as session:
             story_log_dbm = StoryLogDBM(
                 level=StoryLogDBM.Levels.error,
-                title=str(exception),
+                title=f"{status_code}, {type(exception)}",
                 data={
                     "error_so": error_so.model_dump(),
-                    "traceback_str": traceback_str
+                    "traceback_str": exception_to_traceback_str(exception=exception)
                 }
             )
             session.add(story_log_dbm)
-            session.commit()
-            session.refresh(story_log_dbm)
+            await session.commit()
+            await session.refresh(story_log_dbm)
+
         error_so.error_data.update({"story_log_long_id": story_log_dbm.long_id})
         kwargs["story_log_id"] = story_log_dbm.id
+
         return status_code, error_so, kwargs
 
-    return func
+    return async_func
 
 
 def add_exception_handler_to_app(*, app: FastAPI, handle_exception: Callable) -> FastAPI:

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/arpakitlib/ar_sqlalchemy_util.py

@@ -5,7 +5,8 @@ from datetime import timedelta, datetime
 from typing import Any
 from uuid import uuid4
 
-from sqlalchemy import create_engine, QueuePool, text, func
+from sqlalchemy import create_engine, QueuePool, text, func, inspect, AsyncAdaptedQueuePool
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker, AsyncSession
 from sqlalchemy.orm import sessionmaker, DeclarativeBase
 from sqlalchemy.orm.session import Session
 
@@ -26,7 +27,8 @@ class SQLAlchemyDB:
     def __init__(
             self,
             *,
-            db_url: str = "postgresql://arpakitlib:arpakitlib@localhost:50629/arpakitlib",
+            db_url: str = "postgresql://arpakitlib:arpakitlib@localhost:50517/arpakitlib",
+            async_db_url: str = "postgresql+asyncpg://arpakitlib:arpakitlib@localhost:50517/arpakitlib",
             db_echo: bool = False,
             base_dbm: type[BaseDBM] | None = None,
             db_models: list[Any] | None = None,
@@ -35,15 +37,30 @@ class SQLAlchemyDB:
         self.engine = create_engine(
             url=db_url,
             echo=db_echo,
-            pool_size=5,
+            pool_size=10,
             max_overflow=10,
             poolclass=QueuePool,
-            pool_timeout=timedelta(seconds=30).total_seconds()
+            pool_timeout=timedelta(seconds=30).total_seconds(),
         )
         self.sessionmaker = sessionmaker(bind=self.engine)
         self.func_new_session_counter = 0
+        self.async_engine = create_async_engine(
+            url=async_db_url,
+            echo=db_echo,
+            pool_size=10,
+            max_overflow=10,
+            poolclass=AsyncAdaptedQueuePool,
+            pool_timeout=timedelta(seconds=30).total_seconds()
+        )
+        self.async_sessionmaker = async_sessionmaker(bind=self.async_engine)
+        self.func_new_async_session_counter = 0
         self.base_dbm = base_dbm
 
+    def is_table_exists(self, table_name: str) -> bool:
+        with self.engine.connect() as connection:
+            inspector = inspect(connection)
+            return table_name in inspector.get_table_names()
+
     def drop_celery_tables(self):
         with self.engine.connect() as connection:
             connection.execute(text("DROP TABLE IF EXISTS celery_tasksetmeta CASCADE;"))
@@ -52,32 +69,42 @@ class SQLAlchemyDB:
             self._logger.info("celery tables were dropped")
 
     def remove_celery_tables_data(self):
+        if not self.is_table_exists("celery_tasksetmeta"):
+            self._logger.info("table celery_tasksetmeta not exists")
+            return
         with self.engine.connect() as connection:
             connection.execute(text("DELETE FROM celery_tasksetmeta;"))
             connection.execute(text("DELETE FROM celery_taskmeta;"))
             connection.commit()
             self._logger.info("celery tables data were removed")
 
+    def drop_alembic_tables(self):
+        with self.engine.connect() as connection:
+            connection.execute(text("DROP TABLE IF EXISTS alembic_version CASCADE;"))
+            connection.execute(text("DROP TABLE IF EXISTS alembic_version CASCADE;"))
+            connection.commit()
+            self._logger.info("alembic_version tables were dropped")
+
     def remove_alembic_tables_data(self):
+        if not self.is_table_exists("alembic_version"):
+            self._logger.info("table alembic_version not exists")
+            return
         with self.engine.connect() as connection:
             connection.execute(text("DELETE FROM alembic_version;"))
             connection.commit()
             self._logger.info("alembic tables data were removed")
 
     def init(self):
-        from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
-        BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)
+        self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
         self._logger.info("db was inited")
 
     def drop(self):
-        from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
-        BaseDBM.metadata.drop_all(bind=self.engine, checkfirst=True)
+        self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
         self._logger.info("db was dropped")
 
     def reinit(self):
-        from arpakitlib.ar_sqlalchemy_model_util import BaseDBM
-        BaseDBM.metadata.drop_all(bind=self.engine, checkfirst=True)
-        BaseDBM.metadata.create_all(bind=self.engine, checkfirst=True)
+        self.base_dbm.metadata.drop_all(bind=self.engine, checkfirst=True)
+        self.base_dbm.metadata.create_all(bind=self.engine, checkfirst=True)
         self._logger.info("db was reinited")
 
     def check_conn(self):
@@ -88,6 +115,10 @@ class SQLAlchemyDB:
         self.func_new_session_counter += 1
         return self.sessionmaker(**kwargs)
 
+    def new_async_session(self, **kwargs) -> AsyncSession:
+        self.func_new_async_session_counter += 1
+        return self.async_sessionmaker(**kwargs)
+
     def is_conn_good(self) -> bool:
         try:
             self.check_conn()

{arpakitlib-1.7.242 → arpakitlib-1.7.243}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.7.242"
+version = "1.7.243"
 description = "arpakitlib"
 authors = [
     { name = "arpakit", email = "arpakit@gmail.com" },

arpakitlib-1.7.242/arpakitlib/_arpakit_project_template/src/tg_bot/start_tg_bot.py

@@ -1,6 +0,0 @@
-def start_tg_bot():
-    pass
-
-
-if __name__ == '__main__':
-    start_tg_bot()