arpakitlib 1.7.66__py3-none-any.whl → 1.7.124__py3-none-any.whl

arpakitlib/_arpakit_project_template/src/core/util.py

@@ -1,13 +1,10 @@
 import asyncio
-import importlib
-from contextlib import suppress
 from datetime import datetime
 from functools import lru_cache
 
 from arpakitlib.ar_datetime_util import now_dt
 from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
 from arpakitlib.ar_logging_util import setup_normal_logging
-from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
 from arpakitlib.ar_type_util import raise_if_none
 from src.core.settings import get_cached_settings
 
@@ -43,21 +40,6 @@ def get_cached_dump_file_storage_in_dir() -> FileStorageInDir:
     return create_dump_file_storage_in_dir()
 
 
-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()
-
-
 def now_local_dt() -> datetime:
     raise_if_none(get_cached_settings().local_timezone_as_pytz)
     return now_dt(tz=get_cached_settings().local_timezone_as_pytz)

arpakitlib/_arpakit_project_template/{manage/sqlalchemy_db_check_conn.py → src/db/check_conn_sqlalchemy_db.py}

@@ -1,4 +1,5 @@
-from src.core.util import setup_logging, get_cached_sqlalchemy_db
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
 
 
 def command():

arpakitlib/_arpakit_project_template/src/db/init_sqlalchemy_db.py

@@ -0,0 +1,11 @@
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def __init_sqlalchemy_db():
+    setup_logging()
+    get_cached_sqlalchemy_db().init()
+
+
+if __name__ == '__main__':
+    __init_sqlalchemy_db()

arpakitlib/_arpakit_project_template/src/db/reinit_sqlalchemy_db.py

@@ -0,0 +1,13 @@
+from src.core.settings import get_cached_settings
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+
+
+def __reinit_sqlalchemy_db():
+    setup_logging()
+    get_cached_settings().raise_if_mode_type_not_prod()
+    get_cached_sqlalchemy_db().reinit()
+
+
+if __name__ == '__main__':
+    __reinit_sqlalchemy_db()

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/operation_executor.py

@@ -1,14 +1,16 @@
+from sqlalchemy.orm import Session
+
 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:
+    def sync_execute_operation(self, operation_dbm: OperationDBM, session: Session) -> OperationDBM:
         # ...
-        operation_dbm = super().sync_execute_operation(operation_dbm=operation_dbm)
+        operation_dbm = super().sync_execute_operation(operation_dbm=operation_dbm, session=session)
         return operation_dbm
 
-    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    async def async_execute_operation(self, operation_dbm: OperationDBM, session: Session) -> OperationDBM:
         # ...
-        operation_dbm = await super().async_execute_operation(operation_dbm=operation_dbm)
+        operation_dbm = await super().async_execute_operation(operation_dbm=operation_dbm, session=session)
         return operation_dbm

arpakitlib/_arpakit_project_template/src/operation_execution/scheduled_operations.py

@@ -4,14 +4,14 @@ from arpakitlib.ar_operation_execution_util import ScheduledOperation, every_tim
     between_different_times_is_time_func
 from arpakitlib.ar_sqlalchemy_model_util import BaseOperationTypes
 
-ALL_SCHEDULED_OPERATIONS = []
+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)
+SCHEDULED_OPERATIONS.append(healthcheck_1_scheduled_operation)
 
 healthcheck_2_scheduled_operation = ScheduledOperation(
     type=BaseOperationTypes.healthcheck_,
@@ -22,4 +22,4 @@ healthcheck_2_scheduled_operation = ScheduledOperation(
     ),
     timeout_after_creation=timedelta(seconds=60)
 )
-ALL_SCHEDULED_OPERATIONS.append(healthcheck_2_scheduled_operation)
+SCHEDULED_OPERATIONS.append(healthcheck_2_scheduled_operation)

arpakitlib/_arpakit_project_template/src/operation_execution/{start_operation_executor_worker_for_dev.py → start_operation_executor_worker.py}

@@ -1,17 +1,19 @@
 from arpakitlib.ar_operation_execution_util import OperationExecutorWorker
-from src.core.util import get_cached_sqlalchemy_db, setup_logging
+from src.core.settings import get_cached_settings
+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():
+def start_operation_executor_worker():
     setup_logging()
+    get_cached_settings().raise_if_mode_type_prod()
     worker = OperationExecutorWorker(
         sqlalchemy_db=get_cached_sqlalchemy_db(),
-        operation_executor=OperationExecutor(sqlalchemy_db=get_cached_sqlalchemy_db()),
-        filter_operation_types=None
+        operation_executor=OperationExecutor(sqlalchemy_db=get_cached_sqlalchemy_db())
     )
     worker.sync_safe_run()
 
 
 if __name__ == '__main__':
-    start_operation_executor_worker_for_dev()
+    start_operation_executor_worker()

arpakitlib/_arpakit_project_template/src/operation_execution/start_scheduled_operation_creator_worker.py

@@ -0,0 +1,19 @@
+from arpakitlib.ar_operation_execution_util import ScheduledOperationCreatorWorker
+from src.core.settings import get_cached_settings
+from src.core.util import setup_logging
+from src.db.util import get_cached_sqlalchemy_db
+from src.operation_execution.scheduled_operations import SCHEDULED_OPERATIONS
+
+
+def start_scheduled_operation_creator_worker():
+    setup_logging()
+    get_cached_settings().raise_if_mode_type_prod()
+    worker = ScheduledOperationCreatorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        scheduled_operations=SCHEDULED_OPERATIONS
+    )
+    worker.sync_safe_run()
+
+
+if __name__ == '__main__':
+    start_scheduled_operation_creator_worker()

arpakitlib/api_key_util.py

@@ -2,8 +2,20 @@ 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,6 +3,8 @@ 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)
@@ -16,7 +18,22 @@ class BaseAM(BaseModel):
 
 
 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_arpakit_lib_module_util.py

@@ -79,6 +79,12 @@ class ArpakitLibModules(NamedTuple):
             if arpakit_lib_module.module_has_error
         ]
 
+    def have_modules_with_error(self) -> bool:
+        for arpakit_lib_module in self.arpakit_lib_modules:
+            if arpakit_lib_module.module_has_error:
+                return True
+        return False
+
     def module_name_to_module_exception(self, *, filter_module_has_error: bool = False) -> dict[str, BaseException]:
         if filter_module_has_error:
             return {
@@ -144,7 +150,13 @@ 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()
+    print("have_modules_with_error", get_arpakit_lib_modules().have_modules_with_error())
 
 
 if __name__ == '__main__':

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

@@ -7,6 +7,8 @@ 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:

arpakitlib/ar_base_worker_util.py

@@ -6,27 +6,58 @@ import multiprocessing
 import threading
 from abc import ABC
 from datetime import timedelta
+from random import randint
+from typing import Any
+from uuid import uuid4
 
+from arpakitlib.ar_datetime_util import now_utc_dt
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_func_util import is_async_function, is_sync_function
 from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
 class BaseWorker(ABC):
-    def __init__(self):
-        self.worker_name = self.__class__.__name__
-        self._logger = logging.getLogger(self.worker_name)
-        self.timeout_after_run = timedelta(seconds=0.1).total_seconds()
-        self.timeout_after_err_in_run = timedelta(seconds=1).total_seconds()
+    def __init__(
+            self,
+            *,
+            timeout_after_run=timedelta(seconds=0.3),
+            timeout_after_err_in_run=timedelta(seconds=1),
+            startup_funcs: list[Any] | None = None,
+            worker_name: str | None = None
+    ):
+        if startup_funcs is None:
+            startup_funcs = []
+        self.startup_funcs = startup_funcs
+        if worker_name is None:
+            worker_name = self.__class__.__name__
+        self.worker_name = worker_name
+        self.worker_creation_dt = now_utc_dt()
+        self.worker_id = f"{str(uuid4()).replace('-', '')}_{randint(1000, 99999)}"
+        self.worker_fullname = (
+            f"{self.worker_name}_{self.worker_creation_dt.isoformat()}_{self.worker_id}"
+        )
+        self._logger = logging.getLogger(self.worker_fullname)
+        self.timeout_after_run = timeout_after_run
+        self.timeout_after_err_in_run = timeout_after_err_in_run
+
+    def sync_run_startup_funcs(self):
+        for startup_func in self.startup_funcs:
+            if is_async_function(startup_func):
+                asyncio.run(startup_func())
+            elif is_sync_function(startup_func):
+                startup_func()
+            else:
+                raise TypeError("no sync and not async")
 
     def sync_on_startup(self):
-        pass
+        self.sync_run_startup_funcs()
 
     def sync_run(self):
-        self._logger.info("hello world")
+        self._logger.info(f"hello world, im {self.worker_fullname}")
 
-    def sync_run_on_error(self, exception: BaseException, **kwargs):
+    def sync_on_error(self, exception: BaseException, **kwargs):
         pass
 
     def sync_safe_run(self):
@@ -42,20 +73,29 @@ class BaseWorker(ABC):
             except BaseException as exception:
                 self._logger.error("error in sync_run", exc_info=exception)
                 try:
-                    self.sync_run_on_error(exception=exception)
+                    self.sync_on_error(exception=exception)
                 except BaseException as exception_:
-                    self._logger.error("error in sync_run_on_error", exc_info=exception_)
+                    self._logger.error("error in sync_on_error", exc_info=exception_)
                     raise exception_
-            if self.timeout_after_run is not None:
-                sync_safe_sleep(self.timeout_after_run)
+                sync_safe_sleep(self.timeout_after_err_in_run)
+            sync_safe_sleep(self.timeout_after_run)
+
+    async def async_run_startup_funcs(self):
+        for startup_func in self.startup_funcs:
+            if is_async_function(startup_func):
+                await startup_func()
+            elif is_sync_function(startup_func):
+                startup_func()
+            else:
+                raise TypeError("no sync and not async")
 
     async def async_on_startup(self):
-        pass
+        await self.async_run_startup_funcs()
 
     async def async_run(self):
-        self._logger.info("hello world")
+        self._logger.info(f"hello world, im {self.worker_fullname}")
 
-    async def async_run_on_error(self, exception: BaseException, **kwargs):
+    async def async_on_error(self, exception: BaseException, **kwargs):
         pass
 
     async def async_safe_run(self):
@@ -71,12 +111,12 @@ class BaseWorker(ABC):
             except BaseException as exception:
                 self._logger.error("error in async_run", exc_info=exception)
                 try:
-                    await self.async_run_on_error(exception=exception)
+                    await self.async_on_error(exception=exception)
                 except BaseException as exception_:
-                    self._logger.error("error in async_run_on_error", exc_info=exception_)
+                    self._logger.error("error in async_on_error", exc_info=exception_)
                     raise exception_
-            if self.timeout_after_err_in_run is not None:
                 await async_safe_sleep(self.timeout_after_err_in_run)
+            await async_safe_sleep(self.timeout_after_run)
 
 
 class SafeRunInBackgroundModes(Enumeration):
@@ -107,6 +147,15 @@ def safe_run_worker_in_background(*, worker: BaseWorker, mode: str) -> (
     return res
 
 
+def safe_run_workers_in_background(
+        *, workers: list[BaseWorker], mode: str
+) -> list[asyncio.Task] | list[threading.Thread] | list[multiprocessing.Process]:
+    res = []
+    for worker in workers:
+        res.append(safe_run_worker_in_background(worker=worker, mode=mode))
+    return res
+
+
 def __example():
     pass
 

arpakitlib/ar_exception_util.py

@@ -1,5 +1,18 @@
 import traceback
 
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
 
 def exception_to_traceback_str(exception: BaseException) -> str:
     return "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
+
+
+def __example():
+    try:
+        raise Exception()
+    except Exception as exception:
+        print(exception_to_traceback_str(exception))
+
+
+if __name__ == '__main__':
+    __example()