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

arpakitlib/_arpakit_project_template_v_1/core/media_file_storage_in_dir.py

@@ -0,0 +1,23 @@
+from functools import lru_cache
+
+from arpakitlib.ar_file_storage_in_dir_util import FileStorageInDir
+from core.settings import get_cached_settings
+
+
+def create_media_file_storage_in_dir() -> FileStorageInDir | None:
+    if get_cached_settings().media_dirpath is None:
+        return None
+    return FileStorageInDir(dirpath=get_cached_settings().media_dirpath)
+
+
+@lru_cache()
+def get_cached_media_file_storage_in_dir() -> FileStorageInDir | None:
+    return create_media_file_storage_in_dir()
+
+
+def __example():
+    print(get_cached_media_file_storage_in_dir().dirpath)
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/_arpakit_project_template_v_1/core/settings.py

@@ -0,0 +1,195 @@
+import os
+from functools import lru_cache
+from typing import Any
+
+import pytz
+from pydantic import field_validator
+from pydantic_core.core_schema import ValidationInfo
+
+from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
+from arpakitlib.ar_settings_util import SimpleSettings
+from arpakitlib.ar_sqlalchemy_util import generate_sqlalchemy_url
+from core.const import ProjectPaths
+
+
+class ModeTypes(Enumeration):
+    not_prod: str = "not_prod"
+    prod: str = "prod"
+
+
+class Settings(SimpleSettings):
+    mode_type: str = ModeTypes.not_prod
+
+    @field_validator("mode_type")
+    @classmethod
+    def validate_mode_type(cls, v: Any, validation_info: ValidationInfo, **kwargs):
+        if v is None:
+            v = ModeTypes.not_prod
+        ModeTypes.parse_and_validate_values(v.lower().strip())
+        return v
+
+    @property
+    def is_mode_type_not_prod(self) -> bool:
+        return self.mode_type == ModeTypes.not_prod
+
+    def raise_if_mode_type_not_prod(self):
+        if self.is_mode_type_not_prod:
+            raise ValueError(f"mode type = {self.mode_type}")
+
+    @property
+    def is_mode_type_prod(self) -> bool:
+        return self.mode_type == ModeTypes.prod
+
+    def raise_if_mode_type_prod(self):
+        if self.is_mode_type_prod:
+            raise ValueError(f"mode type = {self.mode_type}")
+
+    project_name: str | None = "arpakitlib"
+
+    sqlalchemy_db_user: str | None = project_name
+
+    sqlalchemy_db_password: str | None = project_name
+
+    sqlalchemy_db_host: str | None = "127.0.0.1"
+
+    sqlalchemy_db_port: int | None = 5432
+
+    sqlalchemy_db_database: str | None = project_name
+
+    sqlalchemy_sync_db_url: str | None = None
+
+    @field_validator("sqlalchemy_sync_db_url", mode="after")
+    def validate_sqlalchemy_sync_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+
+        return generate_sqlalchemy_url(
+            base="postgresql",
+            user=validation_info.data.get("sqlalchemy_db_user"),
+            password=validation_info.data.get("sqlalchemy_db_password"),
+            host=validation_info.data.get("sqlalchemy_db_host"),
+            port=validation_info.data.get("sqlalchemy_db_port"),
+            database=validation_info.data.get("sqlalchemy_db_database")
+        )
+
+    sqlalchemy_async_db_url: str | None = None
+
+    @field_validator("sqlalchemy_async_db_url", mode="after")
+    def validate_sqlalchemy_async_db_url(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> str | None:
+        if v is not None:
+            return v
+
+        return generate_sqlalchemy_url(
+            base="postgresql+asyncpg",
+            user=validation_info.data.get("sqlalchemy_db_user"),
+            password=validation_info.data.get("sqlalchemy_db_password"),
+            host=validation_info.data.get("sqlalchemy_db_host"),
+            port=validation_info.data.get("sqlalchemy_db_port"),
+            database=validation_info.data.get("sqlalchemy_db_database")
+        )
+
+    @property
+    def is_any_sql_db_url_set(self) -> bool:
+        if self.sqlalchemy_sync_db_url is not None:
+            return True
+        if self.sqlalchemy_async_db_url is not None:
+            return True
+        return False
+
+    sqlalchemy_db_echo: bool = False
+
+    api_port: int | None = 50519
+
+    api_init_sqlalchemy_db: bool = False
+
+    api_init_json_db: bool = False
+
+    api_correct_api_keys: list[str] | None = ["1"]
+
+    @field_validator("api_correct_api_keys", mode="before")
+    def validate_api_correct_api_keys(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
+        if isinstance(v, str):
+            v = [v]
+        if isinstance(v, int):
+            v = [str(v)]
+        if isinstance(v, list):
+            for i, v_ in enumerate(v):
+                if isinstance(v_, int):
+                    v[i] = str(v_)
+        return v
+
+    api_correct_tokens: list[str] | None = ["1"]
+
+    @field_validator("api_correct_tokens", mode="before")
+    def validate_api_correct_tokens(cls, v: Any, validation_info: ValidationInfo, **kwargs) -> list[str] | None:
+        if isinstance(v, str):
+            v = [v]
+        if isinstance(v, int):
+            v = [str(v)]
+        if isinstance(v, list):
+            for i, v_ in enumerate(v):
+                if isinstance(v_, int):
+                    v[i] = str(v_)
+        return v
+
+    api_enable_sqladmin: bool = True
+
+    api_start_operation_executor_worker: bool = False
+
+    api_start_scheduled_operation_creator_worker: bool = False
+
+    api_story_log__api_func_before_in_exception_handler: bool = False
+
+    sqladmin_secret_key: str | None = "85a9583cb91c4de7a78d7eb1e5306a04418c9c43014c447ea8ec8dd5deb4cf71"
+
+    sqladmin_correct_passwords: list[str] | None = ["1"]
+
+    tg_bot_token: str | None = None
+
+    tg_bot_proxy_url: str | None = None
+
+    tg_bot_init_sqlalchemy_db: bool = False
+
+    tg_bot_init_json_db: bool = False
+
+    tg_bot_webhook_server_hostname: str | None = "127.0.0.1"
+
+    tg_bot_webhook_server_port: int | None = None
+
+    tg_bot_webhook_path: str | None = "/tg_bot_webhook"
+
+    tg_bot_webhook_secret: str | None = "09780c63-22b5-44e2-9b72-f0cf651f7a9a"
+
+    tg_bot_webhook_url: str | None = None
+
+    tg_bot_webhook_enabled: bool = False
+
+    var_dirpath: str | None = os.path.join(ProjectPaths.base_dirpath, "var")
+
+    log_filepath: str | None = os.path.join(var_dirpath, "story.log")
+
+    cache_dirpath: str | None = os.path.join(var_dirpath, "cache")
+
+    media_dirpath: str | None = os.path.join(var_dirpath, "media")
+
+    dump_dirpath: str | None = os.path.join(var_dirpath, "dump")
+
+    json_db_dirpath: str | None = os.path.join(var_dirpath, f"{project_name}_json_db")
+
+    local_timezone: str | None = None
+
+    @property
+    def local_timezone_as_pytz(self) -> Any:
+        return pytz.timezone(self.local_timezone)
+
+
+@lru_cache()
+def get_cached_settings() -> Settings:
+    if os.path.exists(ProjectPaths.env_filepath):
+        return Settings(_env_file=ProjectPaths.env_filepath, _env_file_encoding="utf-8")
+    return Settings()
+
+
+if __name__ == '__main__':
+    print(safely_transfer_obj_to_json_str(get_cached_settings().model_dump(mode="json")))

arpakitlib/_arpakit_project_template_v_1/core/util.py

@@ -0,0 +1,29 @@
+import asyncio
+from datetime import datetime
+
+from arpakitlib.ar_datetime_util import now_dt
+from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_type_util import raise_if_none
+from core.settings import get_cached_settings
+
+
+def setup_logging():
+    setup_normal_logging(log_filepath=get_cached_settings().log_filepath)
+
+
+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)
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/{_arpakit_project_template → _arpakit_project_template_v_1}/example.env

@@ -11,22 +11,28 @@
 # api_port=
 # api_init_sqlalchemy_db=
 # api_init_json_db=
-# api_logging__api_func_before_in_handle_exception=
-# api_story_log__api_func_before_in_handle_exception=
-# api_correct_api_key=
-# api_correct_token=
-# api_enable_admin1=
+# api_correct_api_keys=
+# api_correct_tokens=
+# api_enable_sqladmin=
 # api_start_operation_executor_worker=
 # api_start_scheduled_operation_creator_worker=
-# admin1_secret_key=
+# api_story_log__api_func_before_in_exception_handler=
+# sqladmin_secret_key=
+# sqladmin_correct_passwords=
 # tg_bot_token=
 # tg_bot_proxy_url=
 # tg_bot_init_sqlalchemy_db=
 # tg_bot_init_json_db=
+# tg_bot_webhook_server_hostname=
+# tg_bot_webhook_server_port=
+# tg_bot_webhook_path=
+# tg_bot_webhook_secret=
+# tg_bot_webhook_url=
+# tg_bot_webhook_enabled=
 # var_dirpath=
 # log_filepath=
 # cache_dirpath=
 # media_dirpath=
 # dump_dirpath=
-# local_timezone=
 # json_db_dirpath=
+# local_timezone=

arpakitlib/_arpakit_project_template_v_1/json_db/json_db.py

@@ -0,0 +1,28 @@
+import os
+from functools import lru_cache
+
+from arpakitlib.ar_json_db_util import BaseJSONDb
+from core.settings import get_cached_settings
+
+
+class JSONDb(BaseJSONDb):
+    def __init__(self, dirpath: str):
+        super().__init__()
+        self.story_log = self.create_json_db_file(
+            filepath=os.path.join(dirpath, "story_log.json"), use_memory=True, beautify_json=False
+        )
+
+
+def create_json_db() -> JSONDb | None:
+    if get_cached_settings().json_db_dirpath is None:
+        return None
+    return JSONDb(
+        dirpath=get_cached_settings().json_db_dirpath
+    )
+
+
+@lru_cache()
+def get_cached_json_db() -> JSONDb:
+    return JSONDb(
+        dirpath=get_cached_settings().json_db_dirpath
+    )

arpakitlib/_arpakit_project_template_v_1/operation_execution/operation_executor_worker.py

@@ -0,0 +1,256 @@
+from __future__ import annotations
+
+import inspect
+from datetime import timedelta
+from typing import Any
+
+import sqlalchemy
+from sqlalchemy import asc
+
+from arpakitlib.ar_base_worker_util import BaseWorker
+from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_exception_util import exception_to_traceback_str
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDb
+from arpakitlib.ar_type_util import raise_for_type
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
+from sqlalchemy_db.sqlalchemy_model import OperationDBM, StoryLogDBM
+
+
+class OperationExecutorWorker(BaseWorker):
+
+    def __init__(
+            self,
+            *,
+            sqlalchemy_db: SQLAlchemyDb,
+            filter_operation_types: str | list[str] | None = None,
+            startup_funcs: list[Any] | None = None
+    ):
+        super().__init__(
+            timeout_after_run=timedelta(seconds=0.1),
+            timeout_after_error_in_run=timedelta(seconds=0.1),
+            startup_funcs=startup_funcs,
+        )
+
+        raise_for_type(sqlalchemy_db, SQLAlchemyDb)
+        self.sqlalchemy_db = sqlalchemy_db
+
+        if isinstance(filter_operation_types, str):
+            filter_operation_types = [filter_operation_types]
+        self.filter_operation_types = filter_operation_types
+
+    def sync_execute_operation(self, operation_dbm: OperationDBM):
+        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+            self._logger.info(f"healthcheck {now_utc_dt()}")
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_error_:
+            self._logger.error(f"{OperationDBM.Types.raise_fake_error_}")
+            raise Exception(f"{OperationDBM.Types.raise_fake_error_}")
+        # ...
+
+    async def async_execute_operation(self, *, operation_dbm: OperationDBM):
+        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+            self._logger.info(f"healthcheck {now_utc_dt()}")
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_error_:
+            self._logger.error(f"{OperationDBM.Types.raise_fake_error_}")
+            raise Exception(f"{OperationDBM.Types.raise_fake_error_}")
+        # ...
+
+    def sync_run(self):
+        # 1
+        with self.sqlalchemy_db.new_session() as sync_session:
+            query = (
+                sync_session
+                .query(OperationDBM)
+                .filter(OperationDBM.status == OperationDBM.Statuses.waiting_for_execution)
+            )
+            if self.filter_operation_types is not None:
+                query = query.filter(OperationDBM.type.in_(self.filter_operation_types))
+            query = query.with_for_update()
+            query = query.order_by(asc(OperationDBM.creation_dt))
+            operation_dbm: OperationDBM | None = query.first()
+            if operation_dbm is None:
+                return
+            operation_dbm.execution_start_dt = now_utc_dt()
+            operation_dbm.status = OperationDBM.Statuses.executing
+            operation_dbm.output_data = combine_dicts(
+                operation_dbm.output_data,
+                {
+                    self.worker_fullname: True,
+                    f"{inspect.currentframe().f_code.co_name}": True
+                }
+            )
+            sync_session.commit()
+            sync_session.refresh(operation_dbm)
+
+        # 2
+        self._logger.info(
+            f"start execute_operation"
+            f", operation_id={operation_dbm.id}"
+            f", operation_type={operation_dbm.type})"
+            f", worker_fullname={self.worker_fullname}"
+        )
+        exception_in_execute_operation: Exception | None = None
+        try:
+            self.sync_execute_operation(operation_dbm=operation_dbm)
+        except Exception as exception:
+            self._logger.exception(
+                f"exception in execute_operation"
+                f", operation_id={operation_dbm.id}"
+                f", operation_type={operation_dbm.type}"
+                f", worker_fullname={self.worker_fullname}",
+            )
+            exception_in_execute_operation = exception
+
+        # 3
+        with self.sqlalchemy_db.new_session() as sync_session:
+            operation_dbm: OperationDBM = (
+                sync_session.query(OperationDBM).with_for_update().filter(OperationDBM.id == operation_dbm.id).one()
+            )
+            operation_dbm.execution_finish_dt = now_utc_dt()
+            if exception_in_execute_operation is not None:
+                operation_dbm.status = OperationDBM.Statuses.executed_with_error
+                operation_dbm.error_data = combine_dicts(
+                    operation_dbm.error_data,
+                    {
+                        "exception_in_execute_operation": str(exception_in_execute_operation),
+                        "traceback_str_in_execute_operation": exception_to_traceback_str(
+                            exception=exception_in_execute_operation
+                        ),
+                    }
+                )
+            else:
+                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+            sync_session.commit()
+            sync_session.refresh(operation_dbm)
+        self._logger.info(
+            f"finish execute_operation"
+            f", operation_id={operation_dbm.id}"
+            f", operation_type={operation_dbm.type}"
+            f", worker_fullname={self.worker_fullname}"
+        )
+
+        # 4
+        if exception_in_execute_operation is not None:
+            with self.sqlalchemy_db.new_session() as sync_session:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    type=StoryLogDBM.Types.error_in_execute_operation,
+                    title=(
+                        f"error in execute_operation"
+                        f", operation_id={operation_dbm.id}"
+                        f", operation_type={operation_dbm.type}"
+                    ),
+                    data={
+                        "operation_id": operation_dbm.id,
+                        "operation_type": operation_dbm.type,
+                    }
+                )
+                sync_session.add(story_log_dbm)
+                sync_session.commit()
+                sync_session.refresh(story_log_dbm)
+
+    async def async_run(self):
+        # 1
+        async with self.sqlalchemy_db.new_async_session() as async_session:
+            query = (
+                sqlalchemy.select(OperationDBM)
+                .filter(OperationDBM.status == OperationDBM.Statuses.waiting_for_execution)
+            )
+            if self.filter_operation_types is not None:
+                query = query.filter(OperationDBM.type.in_(self.filter_operation_types))
+            query = query.order_by(asc(OperationDBM.creation_dt)).with_for_update()
+
+            result = await async_session.execute(query)
+            operation_dbm = result.scalars().first()
+            if operation_dbm is None:
+                return
+
+            operation_dbm.execution_start_dt = now_utc_dt()
+            operation_dbm.status = OperationDBM.Statuses.executing
+            operation_dbm.output_data = combine_dicts(
+                operation_dbm.output_data,
+                {
+                    self.worker_fullname: True,
+                    f"{inspect.currentframe().f_code.co_name}": True
+                }
+            )
+            await async_session.commit()
+            await async_session.refresh(operation_dbm)
+
+        # 2
+        self._logger.info(
+            f"start execute_operation"
+            f", operation_id={operation_dbm.id}"
+            f", operation_type={operation_dbm.type})"
+            f", worker_fullname={self.worker_fullname}"
+        )
+        exception_in_execute_operation = None
+        try:
+            await self.async_execute_operation(operation_dbm=operation_dbm)
+        except Exception as exception:
+            self._logger.exception(
+                f"exception in execute_operation"
+                f", operation_id={operation_dbm.id}"
+                f", operation_type={operation_dbm.type}"
+                f", worker_fullname={self.worker_fullname}",
+            )
+            exception_in_execute_operation = exception
+
+        # 3
+        async with self.sqlalchemy_db.new_async_session() as async_session:
+            result = await async_session.execute(
+                sqlalchemy.select(OperationDBM).filter(OperationDBM.id == operation_dbm.id).with_for_update()
+            )
+            operation_dbm = result.scalars().one()
+            operation_dbm.execution_finish_dt = now_utc_dt()
+            if exception_in_execute_operation is not None:
+                operation_dbm.status = OperationDBM.Statuses.executed_with_error
+                operation_dbm.error_data = combine_dicts(
+                    {
+                        "exception_in_execute_operation": str(exception_in_execute_operation),
+                        "traceback_str_in_execute_operation": exception_to_traceback_str(
+                            exception=exception_in_execute_operation
+                        )
+                    },
+                    operation_dbm.error_data
+                )
+            else:
+                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+            await async_session.commit()
+            await async_session.refresh(operation_dbm)
+        self._logger.info(
+            f"finish execute_operation"
+            f", operation_id={operation_dbm.id}"
+            f", operation_type={operation_dbm.type}"
+            f", worker_fullname={self.worker_fullname}"
+        )
+
+        # 4
+        if exception_in_execute_operation is not None:
+            async with self.sqlalchemy_db.new_async_session() as async_session:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    type=StoryLogDBM.Types.error_in_execute_operation,
+                    title=(
+                        f"error in execute_operation"
+                        f", operation_id={operation_dbm.id}"
+                        f", operation_type={operation_dbm.type}"
+                    ),
+                    data={
+                        "operation_id": operation_dbm.id,
+                        "operation_type": operation_dbm.type,
+                    }
+                )
+                async_session.add(story_log_dbm)
+                await async_session.commit()
+                await async_session.refresh(story_log_dbm)
+
+
+def create_operation_executor_worker(
+        *,
+        filter_operation_types: str | list[str] | None = None
+) -> OperationExecutorWorker:
+    return OperationExecutorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        filter_operation_types=filter_operation_types
+    )

arpakitlib/_arpakit_project_template_v_1/operation_execution/scheduled_operation_creator_worker.py

@@ -0,0 +1,106 @@
+from datetime import timedelta
+from typing import Any
+
+from arpakitlib.ar_base_worker_util import BaseWorker
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
+from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDb
+from arpakitlib.ar_type_util import raise_for_type
+from operation_execution.scheduled_operations import ScheduledOperation, get_scheduled_operations
+from sqlalchemy_db.sqlalchemy_db import get_cached_sqlalchemy_db
+from sqlalchemy_db.sqlalchemy_model import OperationDBM
+
+
+class ScheduledOperationCreatorWorker(BaseWorker):
+    def __init__(
+            self,
+            *,
+            sqlalchemy_db: SQLAlchemyDb,
+            scheduled_operations: ScheduledOperation | list[ScheduledOperation] | None = None,
+            startup_funcs: list[Any] | None = None
+    ):
+        super().__init__(
+            timeout_after_run=timedelta(seconds=0.1),
+            timeout_after_error_in_run=timedelta(seconds=0.1),
+            startup_funcs=startup_funcs
+        )
+
+        raise_for_type(sqlalchemy_db, SQLAlchemyDb)
+        self.sqlalchemy_db = sqlalchemy_db
+
+        if scheduled_operations is None:
+            scheduled_operations = []
+        if isinstance(scheduled_operations, ScheduledOperation):
+            scheduled_operations = [scheduled_operations]
+        raise_for_type(scheduled_operations, list)
+        self.scheduled_operations = scheduled_operations
+
+    def sync_run(self):
+        timeout = None
+
+        for scheduled_operation in self.scheduled_operations:
+
+            if not scheduled_operation.is_time_func():
+                continue
+
+            with self.sqlalchemy_db.new_session() as session:
+                operation_dbm = OperationDBM(
+                    type=scheduled_operation.type,
+                    input_data=scheduled_operation.input_data
+                )
+                session.add(operation_dbm)
+                session.commit()
+                session.refresh(operation_dbm)
+            self._logger.info(
+                f"scheduled operation was created"
+                f", operation_id={operation_dbm.id}"
+                f", operation_type={operation_dbm.type}"
+            )
+
+            if scheduled_operation.timeout_after_creation is not None:
+                if timeout is not None:
+                    if scheduled_operation.timeout_after_creation > timeout:
+                        timeout = scheduled_operation.timeout_after_creation
+                else:
+                    timeout = scheduled_operation.timeout_after_creation
+
+        if timeout is not None:
+            sync_safe_sleep(n=timeout)
+
+    async def async_run(self):
+        timeout: timedelta | None = None
+
+        for scheduled_operation in self.scheduled_operations:
+
+            if not scheduled_operation.is_time_func():
+                continue
+
+            async with self.sqlalchemy_db.new_async_session() as async_session:
+                operation_dbm = OperationDBM(
+                    type=scheduled_operation.type,
+                    input_data=scheduled_operation.input_data
+                )
+                async_session.add(operation_dbm)
+                await async_session.commit()
+                await async_session.refresh(operation_dbm)
+            self._logger.info(
+                f"scheduled operation was created"
+                f", operation_id={operation_dbm.id}"
+                f", operation_type={operation_dbm.type}"
+            )
+
+            if scheduled_operation.timeout_after_creation is not None:
+                if timeout is not None:
+                    if scheduled_operation.timeout_after_creation > timeout:
+                        timeout = scheduled_operation.timeout_after_creation
+                else:
+                    timeout = scheduled_operation.timeout_after_creation
+
+        if timeout is not None:
+            await async_safe_sleep(n=timeout)
+
+
+def create_scheduled_operation_creator_worker() -> ScheduledOperationCreatorWorker:
+    return ScheduledOperationCreatorWorker(
+        sqlalchemy_db=get_cached_sqlalchemy_db(),
+        scheduled_operations=get_scheduled_operations()
+    )