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

arpakitlib/ar_operation_execution_util.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 import asyncio
 import logging
 import traceback
-from datetime import timedelta
+from datetime import timedelta, time
 from typing import Any, Callable
 
 from pydantic import ConfigDict
@@ -16,8 +16,10 @@ from sqlalchemy.orm import Session
 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_sqlalchemy_model_util import OperationDBM, StoryLogDBM
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
+from arpakitlib.ar_sqlalchemy_model_util import OperationDBM, StoryLogDBM, BaseOperationTypes
 from arpakitlib.ar_sqlalchemy_util import SQLAlchemyDB
+from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -26,37 +28,101 @@ _logger = logging.getLogger(__name__)
 
 def get_operation_for_execution(
         *,
-        sqlalchemy_db: SQLAlchemyDB,
-        filter_operation_type: str | None = None
+        session: Session | None = None,
+        sqlalchemy_db: SQLAlchemyDB | None = None,
+        filter_operation_types: list[str] | str | None = None
 ) -> OperationDBM | None:
-    with sqlalchemy_db.new_session() as session:
+    if isinstance(filter_operation_types, str):
+        filter_operation_types = [filter_operation_types]
+
+    def func(session_: Session):
         query = (
-            session
+            session_
             .query(OperationDBM)
             .filter(OperationDBM.status == OperationDBM.Statuses.waiting_for_execution)
         )
-        if filter_operation_type:
-            query = query.filter(OperationDBM.type == filter_operation_type)
+        if filter_operation_types:
+            query = query.filter(OperationDBM.type.in_(filter_operation_types))
         query = query.order_by(asc(OperationDBM.creation_dt))
         operation_dbm: OperationDBM | None = query.first()
-    return operation_dbm
+        return operation_dbm
+
+    if session is not None:
+        return func(session_=session)
+    elif sqlalchemy_db is not None:
+        with sqlalchemy_db.new_session() as session:
+            return func(session_=session)
+    else:
+        raise ValueError("session is None and sqlalchemy_db is None")
 
 
 def get_operation_by_id(
         *,
-        session: Session,
+        session: Session | None = None,
+        sqlalchemy_db: SQLAlchemyDB | None = None,
         filter_operation_id: int,
         raise_if_not_found: bool = False
 ) -> OperationDBM | None:
-    query = (
-        session
-        .query(OperationDBM)
-        .filter(OperationDBM.id == filter_operation_id)
-    )
-    if raise_if_not_found:
-        return query.one()
+    def func(session_: Session):
+        query = (
+            session_
+            .query(OperationDBM)
+            .filter(OperationDBM.id == filter_operation_id)
+        )
+        if raise_if_not_found:
+            return query.one()
+        else:
+            return query.one_or_none()
+
+    if session is not None:
+        return func(session_=session)
+    elif sqlalchemy_db is not None:
+        with sqlalchemy_db.new_session() as session:
+            return func(session_=session)
+    else:
+        raise ValueError("session is None and sqlalchemy_db is None")
+
+
+def remove_operations(
+        *,
+        session: Session | None = None,
+        sqlalchemy_db: SQLAlchemyDB | None = None,
+        filter_operation_ids: list[int] | int | None = None,
+        filter_operation_types: list[str] | str | None = None,
+        filter_operation_statuses: list[str] | str | None = None
+):
+    if isinstance(filter_operation_ids, int):
+        filter_operation_ids = [filter_operation_ids]
+    if isinstance(filter_operation_types, str):
+        filter_operation_types = [filter_operation_types]
+    if isinstance(filter_operation_statuses, str):
+        filter_operation_statuses = [filter_operation_statuses]
+
+    if filter_operation_ids is not None:
+        raise_for_type(filter_operation_ids, list)
+    if filter_operation_types is not None:
+        raise_for_type(filter_operation_types, list)
+    if filter_operation_statuses is not None:
+        raise_for_type(filter_operation_statuses, list)
+
+    def func(session_: Session):
+        query = session_.query(OperationDBM)
+        if filter_operation_ids is not None:
+            query = query.filter(OperationDBM.id.in_(filter_operation_ids))
+        if filter_operation_types is not None:
+            query = query.filter(OperationDBM.type.in_(filter_operation_types))
+        if filter_operation_statuses is not None:
+            query = query.filter(OperationDBM.status.in_(filter_operation_statuses))
+        query.delete()
+        session_.commit()
+
+    if session is not None:
+        return func(session_=session)
+    elif sqlalchemy_db is not None:
+        with sqlalchemy_db.new_session() as session:
+            return func(session_=session)
     else:
-        return query.one_or_none()
+        raise ValueError("session is None and sqlalchemy_db is None")
 
 
 class BaseOperationExecutor:
@@ -64,19 +130,20 @@ class BaseOperationExecutor:
         self._logger = logging.getLogger(self.__class__.__name__)
         self.sql_alchemy_db = sqlalchemy_db
 
-    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        if operation_dbm.type == BaseOperationTypes.healthcheck_:
             self._logger.info("healthcheck")
-        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception_:
+        elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
         return operation_dbm
 
-    async def async_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    def sync_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         self._logger.info(
-            f"start async_safe_execute_operation"
-            f", operation_dbm.id={operation_dbm.id}"
-            f", operation_dbm.type={operation_dbm.type}"
+            f"start "
+            f"operation_dbm.id={operation_dbm.id}, "
+            f"operation_dbm.type={operation_dbm.type}, "
+            f"operation_dbm.status={operation_dbm.status}"
         )
 
         with self.sql_alchemy_db.new_session() as session:
@@ -92,9 +159,12 @@ class BaseOperationExecutor:
         traceback_str: str | None = None
 
         try:
-            await self.async_execute_operation(operation_dbm=operation_dbm)
+            self.sync_execute_operation(operation_dbm=operation_dbm)
         except BaseException as exception_:
-            self._logger.exception(exception_)
+            self._logger.error(
+                f"error in sync_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
+                exc_info=exception_
+            )
             exception = exception_
             traceback_str = traceback.format_exc()
 
@@ -107,49 +177,56 @@ class BaseOperationExecutor:
             if exception:
                 operation_dbm.status = OperationDBM.Statuses.executed_with_error
                 operation_dbm.error_data = combine_dicts(
-                    {"exception": str(exception), "traceback_str": traceback_str},
+                    {
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    },
                     operation_dbm.error_data
                 )
             else:
                 operation_dbm.status = OperationDBM.Statuses.executed_without_error
             session.commit()
 
-            story_log_dbm = StoryLogDBM(
-                level=StoryLogDBM.Levels.error,
-                title="Error in async_execute_operation",
-                data={
-                    "operation_id": operation_dbm.id,
-                    "exception_str": str(exception),
-                    "traceback_str": traceback_str
-                }
-            )
-            session.add(story_log_dbm)
-            session.commit()
+            if exception:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    title=f"error in sync_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
+                    data={
+                        "operation_id": operation_dbm.id,
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    }
+                )
+                session.add(story_log_dbm)
+                session.commit()
+                session.refresh(story_log_dbm)
 
             session.refresh(operation_dbm)
-            session.refresh(story_log_dbm)
 
         self._logger.info(
-            f"finish async_safe_execute_operation"
-            f", operation_dbm.id={operation_dbm.id}"
-            f", operation_dbm.type={operation_dbm.type}"
+            f"finish sync_safe_execute_operation, "
+            f"operation_dbm.id={operation_dbm.id}, "
+            f"operation_dbm.type={operation_dbm.type}, "
+            f"operation_dbm.status={operation_dbm.status}, "
+            f"operation_dbm.duration={operation_dbm.duration}"
         )
 
         return operation_dbm
 
-    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        if operation_dbm.type == BaseOperationTypes.healthcheck_:
             self._logger.info("healthcheck")
-        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception_:
+        elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
         return operation_dbm
 
-    def sync_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    async def async_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
         self._logger.info(
-            f"start sync_safe_execute_operation"
-            f", operation_dbm.id={operation_dbm.id}"
-            f", operation_dbm.type={operation_dbm.type}"
+            f"start "
+            f"operation_dbm.id={operation_dbm.id}, "
+            f"operation_dbm.type={operation_dbm.type}, "
+            f"operation_dbm.status={operation_dbm.status}"
         )
 
         with self.sql_alchemy_db.new_session() as session:
@@ -165,9 +242,12 @@ class BaseOperationExecutor:
         traceback_str: str | None = None
 
         try:
-            self.sync_execute_operation(operation_dbm=operation_dbm)
+            await self.async_execute_operation(operation_dbm=operation_dbm)
         except BaseException as exception_:
-            self._logger.exception(exception_)
+            self._logger.error(
+                f"error in async_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
+                exc_info=exception_
+            )
             exception = exception_
             traceback_str = traceback.format_exc()
 
@@ -180,97 +260,103 @@ class BaseOperationExecutor:
             if exception:
                 operation_dbm.status = OperationDBM.Statuses.executed_with_error
                 operation_dbm.error_data = combine_dicts(
-                    {"exception": str(exception), "traceback_str": traceback_str},
+                    {
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    },
                     operation_dbm.error_data
                 )
             else:
                 operation_dbm.status = OperationDBM.Statuses.executed_without_error
             session.commit()
 
-            story_log_dbm = StoryLogDBM(
-                level=StoryLogDBM.Levels.error,
-                title="Error in sync_execute_operation",
-                data={
-                    "operation_id": operation_dbm.id,
-                    "exception_str": str(exception),
-                    "traceback_str": traceback_str
-                }
-            )
-            session.add(story_log_dbm)
-            session.commit()
+            if exception:
+                story_log_dbm = StoryLogDBM(
+                    level=StoryLogDBM.Levels.error,
+                    title=f"error in async_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
+                    data={
+                        "operation_id": operation_dbm.id,
+                        "exception_str": str(exception),
+                        "traceback_str": traceback_str
+                    }
+                )
+                session.add(story_log_dbm)
+                session.commit()
+                session.refresh(story_log_dbm)
 
             session.refresh(operation_dbm)
-            session.refresh(story_log_dbm)
 
         self._logger.info(
-            f"finish sync_safe_execute_operation"
-            f", operation_dbm.id={operation_dbm.id}"
-            f", operation_dbm.type={operation_dbm.type}"
-            f", operation_dbm.duration={operation_dbm.duration}"
+            f"finish async_safe_execute_operation, "
+            f"operation_dbm.id={operation_dbm.id}, "
+            f"operation_dbm.type={operation_dbm.type}, "
+            f"operation_dbm.status={operation_dbm.status}, "
+            f"operation_dbm.duration={operation_dbm.duration}"
         )
 
         return operation_dbm
 
 
-class ExecuteOperationWorker(BaseWorker):
+class OperationExecutorWorker(BaseWorker):
 
     def __init__(
             self,
             *,
             sqlalchemy_db: SQLAlchemyDB,
             operation_executor: BaseOperationExecutor | None = None,
-            filter_operation_type: str | None = None,
-            timeout_after_run=timedelta(seconds=0.1).total_seconds(),
-            timeout_after_err_in_run=timedelta(seconds=1).total_seconds()
+            filter_operation_types: str | list[str] | None = None,
+            timeout_after_run=timedelta(seconds=0.1),
+            timeout_after_err_in_run=timedelta(seconds=1),
+            startup_funcs: list[Any] | None = None
     ):
-        super().__init__()
+        super().__init__(
+            timeout_after_run=timeout_after_run,
+            timeout_after_err_in_run=timeout_after_err_in_run,
+            startup_funcs=startup_funcs
+        )
         self.sqlalchemy_db = sqlalchemy_db
-        self.timeout_after_run = timeout_after_run
-        self.timeout_after_err_in_run = timeout_after_err_in_run
         if operation_executor is None:
             operation_executor = BaseOperationExecutor(sqlalchemy_db=sqlalchemy_db)
         self.operation_executor = operation_executor
-        self.filter_operation_type = filter_operation_type
+        self.filter_operation_types = filter_operation_types
 
-    async def async_on_startup(self):
+    def sync_on_startup(self):
         self.sqlalchemy_db.init()
+        self.sync_run_startup_funcs()
 
-    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        return await self.operation_executor.async_safe_execute_operation(operation_dbm=operation_dbm)
+    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        return self.operation_executor.sync_safe_execute_operation(operation_dbm=operation_dbm)
 
-    async def async_run(self):
+    def sync_run(self):
         operation_dbm: OperationDBM | None = get_operation_for_execution(
             sqlalchemy_db=self.sqlalchemy_db,
-            filter_operation_type=self.filter_operation_type
+            filter_operation_types=self.filter_operation_types
         )
-
         if not operation_dbm:
             return
+        self.sync_execute_operation(operation_dbm=operation_dbm)
 
-        await self.async_execute_operation(operation_dbm=operation_dbm)
-
-    async def async_run_on_error(self, exception: BaseException, **kwargs):
-        self._logger.exception(exception)
+    def sync_run_on_error(self, exception: BaseException, **kwargs):
+        pass
 
-    def sync_on_startup(self):
+    async def async_on_startup(self):
         self.sqlalchemy_db.init()
+        await self.async_run_startup_funcs()
 
-    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        return self.operation_executor.sync_safe_execute_operation(operation_dbm=operation_dbm)
+    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        return await self.operation_executor.async_safe_execute_operation(operation_dbm=operation_dbm)
 
-    def sync_run(self):
+    async def async_run(self):
         operation_dbm: OperationDBM | None = get_operation_for_execution(
             sqlalchemy_db=self.sqlalchemy_db,
-            filter_operation_type=self.filter_operation_type
+            filter_operation_types=self.filter_operation_types
         )
-
         if not operation_dbm:
             return
+        await self.async_execute_operation(operation_dbm=operation_dbm)
 
-        self.sync_execute_operation(operation_dbm=operation_dbm)
-
-    def sync_run_on_error(self, exception: BaseException, **kwargs):
-        self._logger.exception(exception)
+    async def async_run_on_error(self, exception: BaseException, **kwargs):
+        pass
 
 
 class ScheduledOperation(BaseModel):
@@ -279,32 +365,41 @@ class ScheduledOperation(BaseModel):
     type: str
     input_data: dict[str, Any] | None = None
     is_time_func: Callable[[], bool]
+    timeout_after_creation: timedelta | None = None
 
 
-class CreateScheduledOperationWorker(BaseWorker):
+class ScheduledOperationCreatorWorker(BaseWorker):
     def __init__(
             self,
             *,
             sqlalchemy_db: SQLAlchemyDB,
             scheduled_operations: list[ScheduledOperation] | None = None,
-            timeout_after_run=timedelta(seconds=0.1).total_seconds(),
-            timeout_after_err_in_run=timedelta(seconds=1).total_seconds()
+            timeout_after_run=timedelta(seconds=0.1),
+            timeout_after_err_in_run=timedelta(seconds=1),
+            startup_funcs: list[Any] | None = None
     ):
-        super().__init__()
+        super().__init__(
+            timeout_after_run=timeout_after_run,
+            timeout_after_err_in_run=timeout_after_err_in_run,
+            startup_funcs=startup_funcs
+        )
         self.sqlalchemy_db = sqlalchemy_db
-        self.timeout_after_run = timeout_after_run
-        self.timeout_after_err_in_run = timeout_after_err_in_run
         if scheduled_operations is None:
             scheduled_operations = []
         self.scheduled_operations = scheduled_operations
 
     def sync_on_startup(self):
         self.sqlalchemy_db.init()
+        self.sync_run_startup_funcs()
 
     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,
@@ -314,13 +409,28 @@ class CreateScheduledOperationWorker(BaseWorker):
                 session.commit()
                 session.refresh(operation_dbm)
 
-    def async_on_startup(self):
+            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_on_startup(self):
         self.sqlalchemy_db.init()
+        await self.async_run_startup_funcs()
+
+    async def async_run(self):
+        timeout: timedelta | None = None
 
-    def async_run(self):
         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,
@@ -330,6 +440,41 @@ class CreateScheduledOperationWorker(BaseWorker):
                 session.commit()
                 session.refresh(operation_dbm)
 
+            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 every_timedelta_is_time_func(*, td: timedelta, now_dt_func: Callable = now_utc_dt) -> Callable:
+    last_now_utc_dt = now_utc_dt()
+
+    def func() -> bool:
+        nonlocal last_now_utc_dt
+        now_dt_func_ = now_dt_func()
+        if (now_dt_func_ - last_now_utc_dt) >= td:
+            last_now_utc_dt = now_dt_func_
+            return True
+        return False
+
+    return func
+
+
+def between_different_times_is_time_func(
+        *, from_time: time, to_time: time, now_dt_func: Callable = now_utc_dt
+) -> Callable:
+    def func() -> bool:
+        if from_time <= now_dt_func().time() <= to_time:
+            return True
+        return False
+
+    return func
+
 
 def __example():
     pass

arpakitlib/ar_parse_command.py

@@ -1,10 +1,11 @@
 # arpakit
-
+import os
 import shlex
-from typing import Optional
 
 from pydantic import BaseModel
 
+from arpakitlib.ar_enumeration_util import ValuesForParseType
+
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
 
@@ -14,9 +15,19 @@ class BadCommandFormat(Exception):
 
 class ParsedCommand(BaseModel):
     command: str
-    key_to_value: dict[str, Optional[str]] = {}
+    full_command: str
+    key_to_value: dict[str, str | None] = {}
     values_without_key: list[str] = []
 
+    def raise_for_command(self, needed_command: str, lower_: bool = True):
+        needed_command = needed_command.strip()
+
+        if (
+                (self.command.lower() if lower_ else self.command)
+                != (needed_command.lower() if lower_ else needed_command)
+        ):
+            raise ValuesForParseType(f"needed_command != {self.command}, lower_={lower_}")
+
     @property
     def keys(self) -> list[str]:
         return [k for k, v in self.key_to_value.items() if v is not None]
@@ -29,9 +40,15 @@ class ParsedCommand(BaseModel):
     def values(self) -> list[str]:
         return [self.key_to_value[k] for k in self.keys]
 
-    def get_value_by_key(self, key: str) -> Optional[str]:
+    def get_value_by_key(self, key: str) -> str | None:
         return self.key_to_value.get(key)
 
+    def get_value_by_keys(self, keys: list[str]) -> str | None:
+        for key in keys:
+            if self.key_exists(key=key):
+                return self.get_value_by_key(key=key)
+        return None
+
     def key_exists(self, key: str) -> bool:
         return key in self.key_to_value.keys()
 
@@ -44,13 +61,14 @@ class ParsedCommand(BaseModel):
     def has_flag(self, flag: str) -> bool:
         return flag in self.flags
 
-    def get_value_by_index(self, index: int) -> Optional[str]:
+    def get_value_by_index(self, index: int) -> str | None:
         if index >= len(self.values_without_key):
             return None
         return self.values_without_key[index]
 
 
 def parse_command(text: str) -> ParsedCommand:
+    text = text.removeprefix("/")
     text = " ".join([text_.strip() for text_ in text.split(" ") if text_.strip()]).strip()
 
     parts = shlex.split(text)
@@ -59,9 +77,9 @@ def parse_command(text: str) -> ParsedCommand:
     if len(parts[0]) == 1:
         raise BadCommandFormat("len(parts[0]) == 1")
 
-    res = ParsedCommand(command=parts[0])
+    res = ParsedCommand(full_command=parts[0], command=os.path.basename(parts[0]).removeprefix("/"))
 
-    last_key: Optional[str] = None
+    last_key: str | None = None
     for part in parts[1:]:
         part = part.strip()