arpakitlib 1.6.46__py3-none-any.whl → 1.7.89__py3-none-any.whl

arpakitlib/_arpakit_project_template/src/db/util.py

@@ -0,0 +1,21 @@
+import importlib
+from contextlib import suppress
+from functools import lru_cache
+
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+from src.core.settings import get_cached_settings
+
+
+def create_sqlalchemy_db() -> SQLAlchemyDB:
+    with suppress(Exception):
+        importlib.import_module("src.db.sqlalchemy_model")
+
+    return SQLAlchemyDB(
+        db_url=get_cached_settings().sql_db_url,
+        db_echo=get_cached_settings().sql_db_echo
+    )
+
+
+@lru_cache()
+def get_cached_sqlalchemy_db() -> SQLAlchemyDB:
+    return create_sqlalchemy_db()

arpakitlib/_arpakit_project_template/src/operation_execution/const.py

@@ -0,0 +1,9 @@
+from arpakitlib.ar_sqlalchemy_model_util import BaseOperationTypes
+
+
+class OperationTypes(BaseOperationTypes):
+    pass
+
+
+if __name__ == '__main__':
+    OperationTypes.print()

arpakitlib/_arpakit_project_template/src/operation_execution/operation_executor.py

@@ -0,0 +1,14 @@
+from arpakitlib.ar_operation_execution_util import BaseOperationExecutor
+from arpakitlib.ar_sqlalchemy_model_util import OperationDBM
+
+
+class OperationExecutor(BaseOperationExecutor):
+    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        # ...
+        operation_dbm = super().sync_execute_operation(operation_dbm=operation_dbm)
+        return operation_dbm
+
+    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        # ...
+        operation_dbm = await super().async_execute_operation(operation_dbm=operation_dbm)
+        return operation_dbm

arpakitlib/_arpakit_project_template/src/operation_execution/scheduled_operations.py

@@ -0,0 +1,25 @@
+from datetime import timedelta, time
+
+from arpakitlib.ar_operation_execution_util import ScheduledOperation, every_timedelta_is_time_func, \
+    between_different_times_is_time_func
+from arpakitlib.ar_sqlalchemy_model_util import BaseOperationTypes
+
+ALL_SCHEDULED_OPERATIONS = []
+
+healthcheck_1_scheduled_operation = ScheduledOperation(
+    type=BaseOperationTypes.healthcheck_,
+    input_data={"healthcheck_1": "healthcheck_1"},
+    is_time_func=every_timedelta_is_time_func(td=timedelta(seconds=15))
+)
+ALL_SCHEDULED_OPERATIONS.append(healthcheck_1_scheduled_operation)
+
+healthcheck_2_scheduled_operation = ScheduledOperation(
+    type=BaseOperationTypes.healthcheck_,
+    input_data={"healthcheck_2": "healthcheck_2"},
+    is_time_func=between_different_times_is_time_func(
+        from_time=time(hour=12, minute=0),
+        to_time=time(hour=12, minute=15)
+    ),
+    timeout_after_creation=timedelta(seconds=60)
+)
+ALL_SCHEDULED_OPERATIONS.append(healthcheck_2_scheduled_operation)

arpakitlib/_arpakit_project_template/src/operation_execution/start_operation_executor_worker_for_dev.py

@@ -0,0 +1,18 @@
+from arpakitlib.ar_operation_execution_util import OperationExecutorWorker
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+from src.operation_execution.operation_executor import OperationExecutor
+
+
+def start_operation_executor_worker_for_dev():
+    setup_logging()
+    worker = OperationExecutorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        operation_executor=OperationExecutor(sqlalchemy_db=get_cached_sqlalchemy_db()),
+        filter_operation_types=None
+    )
+    worker.sync_safe_run()
+
+
+if __name__ == '__main__':
+    start_operation_executor_worker_for_dev()

arpakitlib/_arpakit_project_template/src/operation_execution/start_scheduled_operation_creator_worker_for_dev.py

@@ -0,0 +1,17 @@
+from arpakitlib.ar_operation_execution_util import ScheduledOperationCreatorWorker
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+from src.operation_execution.scheduled_operations import ALL_SCHEDULED_OPERATIONS
+
+
+def start_create_scheduled_operation_worker_for_dev():
+    setup_logging()
+    worker = ScheduledOperationCreatorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        scheduled_operations=ALL_SCHEDULED_OPERATIONS
+    )
+    worker.sync_safe_run()
+
+
+if __name__ == '__main__':
+    start_create_scheduled_operation_worker_for_dev()

arpakitlib/_arpakit_project_template/src/operation_execution/util.py

@@ -0,0 +1,21 @@
+from datetime import timedelta
+from functools import lru_cache
+
+from arpakitlib.ar_operation_execution_util import ScheduledOperationCreatorWorker
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def create_scheduled_operation_creator_worker() -> ScheduledOperationCreatorWorker:
+    from src.operation_execution.scheduled_operations import ALL_SCHEDULED_OPERATIONS
+    scheduled_operation_creator_worker = ScheduledOperationCreatorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        scheduled_operations=ALL_SCHEDULED_OPERATIONS,
+        timeout_after_run=timedelta(seconds=0.1).total_seconds(),
+        timeout_after_err_in_run=timedelta(seconds=1).total_seconds()
+    )
+    return scheduled_operation_creator_worker
+
+
+@lru_cache()
+def get_scheduled_operation_creator_worker() -> ScheduledOperationCreatorWorker:
+    return create_scheduled_operation_creator_worker()

arpakitlib/_arpakit_project_template/src/test_data/make_test_data_1.py

@@ -0,0 +1,6 @@
+def make_test_data_1():
+    pass
+
+
+async def async_make_test_data_1():
+    pass

arpakitlib/_arpakit_project_template/src/test_data/make_test_data_2.py

@@ -0,0 +1,6 @@
+def make_test_data_2():
+    pass
+
+
+async def async_make_test_data_2():
+    pass

arpakitlib/_arpakit_project_template/src/test_data/make_test_data_3.py

@@ -0,0 +1,6 @@
+def make_test_data_3():
+    pass
+
+
+async def async_make_test_data_3():
+    pass

arpakitlib/_arpakit_project_template/src/test_data/make_test_data_4.py

@@ -0,0 +1,6 @@
+def make_test_data_4():
+    pass
+
+
+async def async_make_test_data_4():
+    pass

arpakitlib/_arpakit_project_template/src/test_data/make_test_data_5.py

@@ -0,0 +1,6 @@
+def make_test_data_5():
+    pass
+
+
+async def async_make_test_data_5():
+    pass

arpakitlib/api_key_util.py

@@ -0,0 +1,21 @@
+from uuid import uuid4
+
+from arpakitlib.ar_datetime_util import now_utc_dt
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def generate_api_key() -> str:
+    return (
+        f"apikey{str(uuid4()).replace('-', '')}{str(now_utc_dt().timestamp()).replace('.', '')}"
+    )
+
+
+def __example():
+    for i in range(5):
+        api_key = generate_api_key()
+        print(f"API-key: {api_key}")
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_additional_model_util.py

@@ -3,14 +3,37 @@ from typing import Any
 
 from pydantic import BaseModel, ConfigDict
 
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
 
 class BaseAM(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
-    bus_data: dict[str, Any] = {}
+    _bus_data: dict[str, Any] | None = None
+
+    @property
+    def bus_data(self) -> dict[str, Any]:
+        if self._bus_data is None:
+            self._bus_data = {}
+        return self._bus_data
 
 
 def __example():
-    pass
+    class UserAM(BaseAM):
+        id: int
+        name: str
+        email: str
+
+        @property
+        def bus_data_age(self) -> int | None:
+            return self.bus_data.get("age")
+
+    user = UserAM(id=1, name="John Doe", email="john.doe@example.com")
+    print(user.name)  # John Doe
+
+    # bus_data
+    user.bus_data["age"] = 22
+    print(user.bus_data)  # {'age': '22'}
+    print(user.bus_data_age)  # 22
 
 
 if __name__ == '__main__':

arpakitlib/ar_aiogram_util.py

@@ -16,8 +16,6 @@ from pydantic import BaseModel, ConfigDict
 
 from arpakitlib.ar_need_type_util import parse_need_type, NeedTypes
 from arpakitlib.ar_parse_command import BadCommandFormat, parse_command
-from arpakitlib.ar_settings_util import SimpleSettings
-from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
 from arpakitlib.ar_type_util import raise_for_types, raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -293,7 +291,7 @@ def as_tg_command(
                                     f"Value (key={_param.key}, index={_param.index}) is required"
                                 )
                         else:
-                            value = parse_need_type(value=value, need_type=_param.need_type)
+                            value = parse_need_type(value=value, need_type=_param.need_type, allow_none=False)
 
                         kwargs[_param.key] = value
 
@@ -327,27 +325,21 @@ class SimpleMiddleware(BaseMiddleware, ABC):
 class BaseTransmittedTgBotData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
-    tg_bot: Bot
-    settings: SimpleSettings | None = None
 
+def create_aiogram_tg_bot(*, tg_bot_token: str, tg_bot_proxy_url: str | None = None, **kwargs) -> Bot:
+    kwargs["token"] = tg_bot_token
 
-class SimpleTransmittedTgBotData(BaseTransmittedTgBotData):
-    sqlalchemy_db: SQLAlchemyDB | None = None
-
-
-def create_aiogram_tg_bot(*, tg_bot_token: str, tg_bot_proxy_url: str | None = None) -> Bot:
-    session: AiohttpSession | None = None
     if tg_bot_proxy_url:
-        session = AiohttpSession(proxy=tg_bot_proxy_url)
-    tg_bot = Bot(
-        token=tg_bot_token,
-        default=DefaultBotProperties(
+        kwargs["session"] = AiohttpSession(proxy=tg_bot_proxy_url)
+
+    if kwargs.get("default") is None:
+        kwargs["default"] = DefaultBotProperties(
             parse_mode=ParseMode.HTML,
             disable_notification=False,
             link_preview_is_disabled=True
-        ),
-        session=session
-    )
+        )
+
+    tg_bot = Bot(**kwargs)
 
     return tg_bot
 

arpakitlib/ar_arpakit_lib_module_util.py

@@ -144,7 +144,12 @@ def get_arpakit_lib_modules() -> ArpakitLibModules:
 
 
 def __example():
-    pass
+    for module_name, d in (
+            get_arpakit_lib_modules().module_name_to_module_version_and_module_has_errors().items()
+    ):
+        print(module_name)
+        print(d)
+        print()
 
 
 if __name__ == '__main__':

arpakitlib/ar_arpakit_project_template_util.py

@@ -0,0 +1,96 @@
+# arpakit
+
+import logging
+import os
+
+from arpakitlib.ar_str_util import make_none_if_blank, raise_if_string_blank
+from arpakitlib.ar_type_util import raise_for_type
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+_logger = logging.getLogger(__name__)
+
+
+def init_arpakit_project_template(
+        *,
+        project_dirpath: str = "./",
+        overwrite_if_exists: bool = False,
+        project_name: str | None = None,
+        sql_db_port: int | None = None,
+        api_port: int | None = None,
+        ignore_paths_startswith: list[str] | str | None = None,
+        only_paths_startswith: list[str] | str | None = None,
+):
+    raise_if_string_blank(project_dirpath)
+
+    if project_name:
+        project_name = project_name.strip()
+    project_name = make_none_if_blank(project_name)
+
+    if sql_db_port is not None:
+        raise_for_type(sql_db_port, int)
+
+    if api_port is not None:
+        raise_for_type(api_port, int)
+
+    if isinstance(ignore_paths_startswith, str):
+        ignore_paths_startswith = [ignore_paths_startswith]
+    if ignore_paths_startswith is None:
+        ignore_paths_startswith = []
+
+    if isinstance(only_paths_startswith, str):
+        only_paths_startswith = [only_paths_startswith]
+    if only_paths_startswith is None:
+        only_paths_startswith = []
+
+    def _generate_filepath_to_content() -> dict[str, str]:
+        arpakit_project_template_dirpath = os.path.join(
+            os.path.dirname(os.path.abspath(__file__)), "_arpakit_project_template"
+        )
+        res = {}
+        for root, dirs, files in os.walk(arpakit_project_template_dirpath):
+            dirs[:] = [d for d in dirs if d != '__pycache__']
+            for file in files:
+                rel_path = os.path.relpath(os.path.join(root, file), arpakit_project_template_dirpath)
+                if (
+                        ignore_paths_startswith
+                        and
+                        any(rel_path.startswith(ignore_path) for ignore_path in ignore_paths_startswith)
+                ):
+                    _logger.info(f"ignoring file: {rel_path}")
+                    continue
+                if (
+                        only_paths_startswith
+                        and
+                        not any(rel_path.startswith(only_path) for only_path in only_paths_startswith)
+                ):
+                    _logger.info(f"ignoring file: {rel_path}")
+                    continue
+                with open(os.path.join(root, file), "r", encoding="utf-8") as _file:
+                    _content = _file.read()
+                if project_name is not None:
+                    _content = _content.replace("{PROJECT_NAME}", project_name)
+                if sql_db_port is not None:
+                    _content = _content.replace("{SQL_DB_PORT}", str(sql_db_port))
+                if api_port is not None:
+                    _content = _content.replace("{API_PORT}", str(api_port))
+                res[rel_path] = _content
+        return res
+
+    filepath_to_content = _generate_filepath_to_content()
+
+    if not os.path.exists(project_dirpath):
+        os.makedirs(project_dirpath)
+
+    for filepath, content in filepath_to_content.items():
+        full_filepath = os.path.join(project_dirpath, filepath)
+
+        if os.path.exists(full_filepath) and not overwrite_if_exists:
+            _logger.info(f"file exists and overwrite_if_exists is False, skipping: {full_filepath}")
+            continue
+
+        _logger.info(f"creating file: {full_filepath}")
+        os.makedirs(os.path.dirname(full_filepath), exist_ok=True)
+        with open(full_filepath, "w", encoding="utf-8") as file_:
+            file_.write(content)
+        _logger.info(f"file created: {full_filepath}")

arpakitlib/ar_arpakit_schedule_uust_api_client_util.py

@@ -17,7 +17,7 @@ from pydantic import ConfigDict, BaseModel
 
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration_util import Enumeration
-from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 from arpakitlib.ar_sleep_util import async_safe_sleep
 from arpakitlib.ar_type_util import raise_for_type
 
@@ -53,7 +53,7 @@ class BaseAPIModel(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
     def simple_json(self) -> str:
-        return safely_transfer_to_json_str(self.model_dump(mode="json"))
+        return safely_transfer_obj_to_json_str(self.model_dump(mode="json"))
 
 
 class GroupAPIModel(BaseAPIModel):
@@ -521,7 +521,28 @@ def __example():
 
 
 async def __async_example():
-    pass
+    client = ARPAKITScheduleUUSTAPIClient(api_key="TEST_API_KEY", use_cache=True)
+
+    healthcheck = await client.healthcheck()
+    print(f"Healthcheck: {healthcheck}")
+
+    auth_healthcheck = await client.auth_healthcheck()
+    print(f"Auth Healthcheck: {auth_healthcheck}")
+
+    current_week = await client.get_current_week()
+    print(f"Текущая неделя: {current_week.simple_json() if current_week else 'Не найдено'}")
+
+    current_semester = await client.get_current_semester()
+    print(f"Текущий семестр: {current_semester.simple_json() if current_semester else 'Не найдено'}")
+
+    groups = await client.get_groups()
+    print(f"Группы: {[group.simple_json() for group in groups]}")
+
+    teachers = await client.get_teachers()
+    print(f"Преподаватели: {[teacher.simple_json() for teacher in teachers]}")
+
+    weather = await client.get_weather_in_ufa()
+    print(f"Погода в Уфе: {weather.simple_json()}")
 
 
 if __name__ == '__main__':

arpakitlib/ar_arpakitlib_cli_util.py

@@ -0,0 +1,79 @@
+# arpakit
+
+import sys
+
+from arpakitlib.ar_arpakit_project_template_util import init_arpakit_project_template
+from arpakitlib.ar_need_type_util import parse_need_type, NeedTypes
+from arpakitlib.ar_parse_command import parse_command
+from arpakitlib.ar_str_util import raise_if_string_blank
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+def execute_arpakitlib_cli(*, full_command: str | None = None):
+    if full_command is None:
+        full_command = " ".join(sys.argv)
+
+    parsed_command = parse_command(text=full_command)
+    parsed_command.raise_for_command(needed_command="arpakitlib", lower_=True)
+
+    command = parsed_command.get_value_by_keys(keys=["command", "c"])
+    if command:
+        command = command.strip()
+    if not command:
+        raise Exception(f"not command, command={command}")
+
+    if command == "help":
+        print("Commands:")
+        print()
+        print("-c init_arpakit_project_template")
+        print("-project_dirpath ...")
+        print("-overwrite_if_exists ...")
+        print("-project_name ...")
+        print("-sql_db_port ...")
+        print("-api_port ...")
+        print("-ignore_paths_startswith ...")
+        print("-only_paths_startswith ...")
+        print("\n")
+
+    elif command == "init_arpakit_project_template":
+        project_dirpath = raise_if_string_blank(parsed_command.get_value_by_keys(keys=["pd", "project_dirpath"]))
+        overwrite_if_exists: bool = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["oie", "overwrite_if_exists"]),
+            need_type=NeedTypes.bool_,
+            allow_none=False
+        )
+        project_name: str = parsed_command.get_value_by_keys(keys=["pm", "project_name"])
+        project_name = project_name.strip() if project_name.strip() else None
+        sql_db_port: int | None = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["sdp", "sql_db_port"]),
+            need_type=NeedTypes.int_,
+            allow_none=True
+        )
+        api_port: int | None = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["ap", "api_port"]),
+            need_type=NeedTypes.int_,
+            allow_none=True
+        )
+        ignore_paths_startswith: list[str] | None = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["ipsw", "ignore_paths_startswith"]),
+            need_type=NeedTypes.list_of_str,
+            allow_none=True
+        )
+        only_paths_startswith: list[str] | None = parse_need_type(
+            value=parsed_command.get_value_by_keys(keys=["ops", "only_paths_startswith"]),
+            need_type=NeedTypes.list_of_str,
+            allow_none=True
+        )
+        init_arpakit_project_template(
+            project_dirpath=project_dirpath, overwrite_if_exists=overwrite_if_exists,
+            project_name=project_name, sql_db_port=sql_db_port, api_port=api_port,
+            ignore_paths_startswith=ignore_paths_startswith, only_paths_startswith=only_paths_startswith
+        )
+
+    else:
+        raise Exception(f"not recognized command, command={command}")
+
+
+if __name__ == '__main__':
+    execute_arpakitlib_cli(full_command="/arpakitlib -c help")