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

arpakitlib/_arpakit_project_template_v_4/arpakitlib_project_template_info.json

@@ -0,0 +1,3 @@
+{
+  "arpakitlib_project_template_version": "3"
+}

arpakitlib/_arpakit_project_template_v_4/command/beautify_json.py

@@ -0,0 +1,10 @@
+from arpakitlib.ar_json_util import transfer_json_str_to_data_to_json_str
+
+
+def __command():
+    s = input("JSON:\n")
+    print(transfer_json_str_to_data_to_json_str(s))
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_4/command/demojize.py

@@ -0,0 +1,9 @@
+from emoji import demojize
+
+
+def __command():
+    print(demojize(input("text: ").strip()))
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/drop_json_db.py

@@ -5,7 +5,7 @@ from project.json_db.json_db import get_cached_json_db
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     get_cached_json_db().drop()
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/drop_sqlalchemy_db.py

@@ -5,7 +5,7 @@ from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     get_cached_sqlalchemy_db().drop()
     get_cached_sqlalchemy_db().drop_celery_tables()
     get_cached_sqlalchemy_db().drop_alembic_tables()

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/generate_settings_env_example.py

@@ -1,12 +1,12 @@
 import os.path
 
-from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_json_util import transfer_data_to_json_str
 from project.core.const import ProjectPaths
 from project.core.settings import get_cached_settings, Settings
 
 
 def __command():
-    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")))
     Settings.save_env_example_to_file(filepath=os.path.join(ProjectPaths.base_dirpath, "example.env"))
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/reinit_json_db.py

@@ -5,7 +5,7 @@ from project.json_db.json_db import get_cached_json_db
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     get_cached_json_db().reinit()
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/reinit_sqlalchemy_db.py

@@ -5,7 +5,7 @@ from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_prod_mode()
     get_cached_sqlalchemy_db().reinit()
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/remove_operations.py

@@ -5,7 +5,7 @@ from project.core.util import setup_logging
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     remove_operations()
 
 

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/remove_story_logs.py

@@ -6,7 +6,7 @@ from project.sqlalchemy_db_.sqlalchemy_model import StoryLogDBM
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     with get_cached_sqlalchemy_db().new_session() as session:
         session.query(StoryLogDBM).delete()
         session.commit()

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/command/rm_all_records_in_json_db.py

@@ -5,7 +5,7 @@ from project.json_db.json_db import get_cached_json_db
 
 def __command():
     setup_logging()
-    get_cached_settings().raise_if_mode_type_prod()
+    get_cached_settings().raise_if_mode_prod()
     get_cached_json_db().rm_all_records()
 
 

arpakitlib/_arpakit_project_template_v_4/command/set_tg_bot_commands.py

@@ -0,0 +1,16 @@
+import asyncio
+
+from project.core.util import setup_logging
+from project.tg_bot.tg_bot import get_cached_tg_bot
+from project.tg_bot.util.set_tg_bot_commands import set_client_tg_bot_commands, set_admin_tg_bot_commands
+
+
+async def __async_command():
+    setup_logging()
+    await set_client_tg_bot_commands()
+    await set_admin_tg_bot_commands()
+    await get_cached_tg_bot().session.close()
+
+
+if __name__ == '__main__':
+    asyncio.run(__async_command())

arpakitlib/_arpakit_project_template_v_4/command/show_settings.py

@@ -0,0 +1,10 @@
+from arpakitlib.ar_json_util import transfer_data_to_json_str
+from project.core.settings import get_cached_settings
+
+
+def __command():
+    print(transfer_data_to_json_str(get_cached_settings().model_dump(mode="json")))
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_4/command/start_sqladmin.py

@@ -0,0 +1,19 @@
+import uvicorn
+
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+
+
+def __command():
+    setup_logging()
+    uvicorn.run(
+        "project.sqladmin_.asgi:app",
+        port=get_cached_settings().sqladmin_port,
+        host="localhost",
+        workers=1,
+        reload=False
+    )
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_4/command/start_sqladmin_for_prod.py

@@ -0,0 +1,19 @@
+import uvicorn
+
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+
+
+def __command():
+    setup_logging()
+    uvicorn.run(
+        "project.sqladmin_.asgi:app",
+        port=get_cached_settings().sqladmin_port,
+        host="localhost",
+        workers=1,
+        reload=False
+    )
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_4/command/start_sqladmin_with_reload.py

@@ -0,0 +1,19 @@
+import uvicorn
+
+from project.core.settings import get_cached_settings
+from project.core.util import setup_logging
+
+
+def __command():
+    setup_logging()
+    uvicorn.run(
+        "project.sqladmin_.asgi:app",
+        port=get_cached_settings().sqladmin_port,
+        host="localhost",
+        workers=1,
+        reload=True
+    )
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/_arpakit_project_template_v_4/command/start_tg_bot_for_prod.py

@@ -0,0 +1,11 @@
+from project.core.util import setup_logging
+from project.tg_bot.start_tg_bot import start_tg_bot
+
+
+def __command():
+    setup_logging()
+    start_tg_bot()
+
+
+if __name__ == '__main__':
+    __command()

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/example.env

@@ -1,4 +1,4 @@
-# mode_type=
+# prod_mode=
 # project_name=
 # sqlalchemy_db_user=
 # sqlalchemy_db_password=
@@ -11,14 +11,15 @@
 # api_port=
 # api_init_sqlalchemy_db=
 # api_init_json_db=
-# api_correct_api_keys=
-# api_correct_tokens=
+# api_api_keys=
+# api_user_tokens=
 # api_enable_sqladmin=
 # api_start_operation_executor_worker=
 # api_start_scheduled_operation_creator_worker=
-# api_story_log__api_func_before_in_exception_handler=
+# api_create_story_log_func_before_in_exception_handler=
 # sqladmin_secret_key=
-# sqladmin_correct_passwords=
+# sqladmin_auth_keys=
+# sqladmin_port=
 # tg_bot_token=
 # tg_bot_proxy_url=
 # tg_bot_init_sqlalchemy_db=
@@ -29,6 +30,11 @@
 # tg_bot_webhook_secret=
 # tg_bot_webhook_url=
 # tg_bot_webhook_enabled=
+# tg_bot_drop_pending_updates=
+# tg_bot_start_operation_executor_worker=
+# tg_bot_start_scheduled_operation_creator_worker=
+# tg_bot_command_passwd=
+# tg_bot_admin_tg_ids=
 # var_dirpath=
 # log_filepath=
 # cache_dirpath=

arpakitlib/_arpakit_project_template_v_4/project/additional_model/common.py

@@ -0,0 +1,8 @@
+from typing import Any
+
+from pydantic import ConfigDict, BaseModel
+
+
+class BaseAM(BaseModel):
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+    additional_data: dict[str, Any] = {}

arpakitlib/{_arpakit_project_template_v_2 → _arpakit_project_template_v_4}/project/api/auth.py

@@ -4,16 +4,19 @@ import fastapi
 import fastapi.exceptions
 import fastapi.responses
 import fastapi.security
+import sqlalchemy
 from fastapi import Security
 from fastapi.security import APIKeyHeader
 from pydantic import BaseModel, ConfigDict
 
 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_json_util import transfer_data_to_json_str_to_data
 from arpakitlib.ar_type_util import raise_for_type
 from project.api.const import APIErrorCodes
 from project.api.exception import APIException
 from project.core.settings import get_cached_settings
+from project.sqlalchemy_db_.sqlalchemy_db import get_cached_sqlalchemy_db
+from project.sqlalchemy_db_.sqlalchemy_model import ApiKeyDBM, UserTokenDBM
 
 
 class APIAuthData(BaseModel):
@@ -30,11 +33,14 @@ class APIAuthData(BaseModel):
 
     current_mode_type: str | None = None
 
-    user_token_string: str | None = None
     api_key_string: str | None = None
+    user_token_string: str | None = None
 
-    is_user_token_correct: bool | None = None
     is_api_key_correct: bool | None = None
+    is_user_token_correct: bool | None = None
+
+    api_key_dbm: ApiKeyDBM | None = None
+    user_token_dbm: UserTokenDBM | None = None
 
 
 def api_auth(
@@ -48,8 +54,8 @@ def api_auth(
         require_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,
+        is_api_key_correct_func: Callable | None = None,
+        is_user_token_correct_func: Callable | None = None,
         correct_api_keys: str | list[str] | None = None,
         correct_user_tokens: str | list[str] | None = None,
 ) -> Callable:
@@ -58,8 +64,8 @@ def api_auth(
     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 = (
+    if is_api_key_correct_func is None and correct_api_keys is not None:
+        is_api_key_correct_func = (
             lambda *args, **kwargs_: kwargs_["api_auth_data"].api_key_string in correct_api_keys
         )
 
@@ -68,8 +74,8 @@ def api_auth(
     if correct_user_tokens is not None:
         raise_for_type(correct_user_tokens, list)
 
-    if validate_user_token_func is None and correct_user_tokens is not None:
-        validate_user_token_func = (
+    if is_user_token_correct_func is None and correct_user_tokens is not None:
+        is_user_token_correct_func = (
             lambda *args, **kwargs_: kwargs_["api_auth_data"].user_token_string in correct_user_tokens
         )
 
@@ -159,7 +165,7 @@ def api_auth(
                 raise APIException(
                     status_code=fastapi.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())
+                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
                 )
 
         # require_not_mode_type
@@ -169,7 +175,7 @@ def api_auth(
                 raise APIException(
                     status_code=fastapi.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())
+                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
                 )
 
         # require_api_key_string
@@ -178,7 +184,7 @@ def api_auth(
             raise APIException(
                 status_code=fastapi.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())
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
         # require_token_string
@@ -187,32 +193,38 @@ def api_auth(
             raise APIException(
                 status_code=fastapi.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())
+                error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
             )
 
-        # validate_api_key_func
+        # is_api_key_correct_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(
+        if is_api_key_correct_func is not None:
+            if is_async_callable(is_api_key_correct_func):
+                await is_api_key_correct_func(
+                    api_auth_data=api_auth_data,
+                    request=request
+                )
+            elif is_sync_function(is_api_key_correct_func):
+                is_api_key_correct_func(
                     api_auth_data=api_auth_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
+        # is_user_token_correct_func
 
-        if validate_user_token_func is not None:
-            if is_async_callable(validate_user_token_func):
-                api_auth_data.is_user_token_correct = await validate_user_token_func(
+        if is_user_token_correct_func is not None:
+            if is_async_callable(is_user_token_correct_func):
+                await is_user_token_correct_func(
+                    api_auth_data=api_auth_data,
+                    request=request
+                )
+            elif is_sync_function(is_user_token_correct_func):
+                is_user_token_correct_func(
                     api_auth_data=api_auth_data,
                     request=request
                 )
-            elif is_sync_function(validate_user_token_func):
-                api_auth_data.is_user_token_correct = validate_user_token_func()
             else:
                 raise TypeError("unknown validate_token_func type")
 
@@ -224,7 +236,7 @@ def api_auth(
                     status_code=fastapi.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()),
+                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump()),
                 )
 
         # require_correct_token
@@ -234,8 +246,8 @@ def api_auth(
                 raise APIException(
                     status_code=fastapi.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())
+                    error_description="not api_auth_data.is_user_token_correct",
+                    error_data=transfer_data_to_json_str_to_data(api_auth_data.model_dump())
                 )
 
         return api_auth_data
@@ -250,12 +262,16 @@ def correct_api_keys_from_settings__is_api_key_correct_func() -> Callable:
             request: fastapi.requests.Request,
     ):
         if get_cached_settings().api_correct_api_keys is None:
-            return False
+            api_auth_data.is_api_key_correct = False
+            return
         if api_auth_data.api_key_string is None:
-            return False
+            api_auth_data.is_api_key_correct = False
+            return
         if api_auth_data.api_key_string.strip() not in get_cached_settings().api_correct_api_keys:
-            return False
-        return True
+            api_auth_data.is_api_key_correct = False
+            return
+        api_auth_data.is_api_key_correct = True
+        return
 
     return async_func
 
@@ -267,11 +283,71 @@ def correct_tokens_from_settings__is_user_token_correct_func() -> Callable:
             request: fastapi.requests.Request,
     ):
         if get_cached_settings().api_correct_tokens is None:
-            return False
+            api_auth_data.is_api_key_correct = False
+            return
         if api_auth_data.user_token_string is None:
-            return False
+            api_auth_data.is_api_key_correct = False
+            return
         if api_auth_data.user_token_string.strip() not in get_cached_settings().api_correct_tokens:
-            return False
+            api_auth_data.is_api_key_correct = False
+            return
+        api_auth_data.is_api_key_correct = True
+        return
+
+    return async_func
+
+
+def correct_api_key_from_sqlalchemy_db__is_api_key_correct_func() -> Callable:
+    async def async_func(
+            *,
+            api_auth_data: APIAuthData,
+            request: fastapi.requests.Request,
+    ):
+        if api_auth_data.api_key_string is None:
+            api_auth_data.is_api_key_correct = False
+            return
+
+        async with get_cached_sqlalchemy_db().new_async_session() as session:
+            api_auth_data.api_key_dbm = await session.scalar(
+                sqlalchemy.select(ApiKeyDBM).where(ApiKeyDBM.value == api_auth_data.api_key_string)
+            )
+
+        if api_auth_data.api_key_dbm is None or not api_auth_data.api_key_dbm.is_enabled:
+            api_auth_data.is_api_key_correct = False
+            return
+
+        api_auth_data.is_api_key_correct = True
         return True
 
     return async_func
+
+
+def correct_user_token_from_sqlalchemy_db__is_user_token_correct_func(
+        *, require_user_roles: list[str] | None = None
+) -> Callable:
+    async def async_func(
+            *,
+            api_auth_data: APIAuthData,
+            request: fastapi.requests.Request,
+    ):
+        if api_auth_data.user_token_string is None:
+            api_auth_data.is_user_token_correct = False
+            return
+
+        with get_cached_sqlalchemy_db().new_session() as session:
+            api_auth_data.user_token_dbm = session.query(
+                UserTokenDBM
+            ).filter(
+                UserTokenDBM.value == api_auth_data.user_token_string
+            ).one_or_none()
+
+        if api_auth_data.user_token_dbm is None:
+            api_auth_data.is_user_token_correct = False
+            return
+        if not api_auth_data.user_token_dbm.is_enabled:
+            pass
+
+        api_auth_data.is_user_token_correct = True
+        return
+
+    return async_func