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

arpakitlib/ar_operation_execution_util.py

@@ -11,6 +11,7 @@ from typing import Any, Callable
 from pydantic import ConfigDict
 from pydantic.v1 import BaseModel
 from sqlalchemy import asc
+from sqlalchemy.exc import NoResultFound
 from sqlalchemy.orm import Session
 
 from arpakitlib.ar_base_worker_util import BaseWorker
@@ -30,7 +31,8 @@ def get_operation_for_execution(
         *,
         session: Session | None = None,
         sqlalchemy_db: SQLAlchemyDB | None = None,
-        filter_operation_types: list[str] | str | None = None
+        filter_operation_types: list[str] | str | None = None,
+        lock: bool = False
 ) -> OperationDBM | None:
     if isinstance(filter_operation_types, str):
         filter_operation_types = [filter_operation_types]
@@ -43,6 +45,10 @@ def get_operation_for_execution(
         )
         if filter_operation_types:
             query = query.filter(OperationDBM.type.in_(filter_operation_types))
+
+        if lock:
+            query = query.with_for_update()
+
         query = query.order_by(asc(OperationDBM.creation_dt))
         operation_dbm: OperationDBM | None = query.first()
         return operation_dbm
@@ -61,7 +67,8 @@ def get_operation_by_id(
         session: Session | None = None,
         sqlalchemy_db: SQLAlchemyDB | None = None,
         filter_operation_id: int,
-        raise_if_not_found: bool = False
+        raise_if_not_found: bool = False,
+        lock: bool = False
 ) -> OperationDBM | None:
     def func(session_: Session):
         query = (
@@ -69,8 +76,16 @@ def get_operation_by_id(
             .query(OperationDBM)
             .filter(OperationDBM.id == filter_operation_id)
         )
+
+        if lock:
+            query = query.with_for_update()
+
         if raise_if_not_found:
-            return query.one()
+            try:
+                return query.one()
+            except NoResultFound:
+                if raise_if_not_found:
+                    raise ValueError("Operation not found")
         else:
             return query.one_or_none()
 
@@ -130,21 +145,17 @@ class BaseOperationExecutor:
         self._logger = logging.getLogger(self.__class__.__name__)
         self.sql_alchemy_db = sqlalchemy_db
 
-    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    def sync_execute_operation(self, operation_dbm: OperationDBM, session: Session) -> OperationDBM:
         if operation_dbm.type == BaseOperationTypes.healthcheck_:
             self._logger.info("healthcheck")
         elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
-        else:
-            raise Exception(
-                f"unknown operation_dbm.type,"
-                f" operation_dbm.id={operation_dbm.id},"
-                f" operation_dbm.type={operation_dbm.type}"
-            )
         return operation_dbm
 
-    def sync_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    def sync_safe_execute_operation(
+            self, operation_dbm: OperationDBM, worker: OperationExecutorWorker, session: Session
+    ) -> OperationDBM:
         self._logger.info(
             f"start "
             f"operation_dbm.id={operation_dbm.id}, "
@@ -152,20 +163,21 @@ class BaseOperationExecutor:
             f"operation_dbm.status={operation_dbm.status}"
         )
 
-        with self.sql_alchemy_db.new_session() as session:
-            operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
-            )
-            operation_dbm.execution_start_dt = now_utc_dt()
-            operation_dbm.status = OperationDBM.Statuses.executing
-            session.commit()
-            session.refresh(operation_dbm)
+        operation_dbm.execution_start_dt = now_utc_dt()
+        operation_dbm.status = OperationDBM.Statuses.executing
+        operation_dbm.output_data = combine_dicts(
+            operation_dbm.output_data,
+            {
+                worker.worker_fullname: True
+            }
+        )
+        session.commit()
 
         exception: BaseException | None = None
         traceback_str: str | None = None
 
         try:
-            self.sync_execute_operation(operation_dbm=operation_dbm)
+            self.sync_execute_operation(operation_dbm=operation_dbm, session=session)
         except BaseException as exception_:
             self._logger.error(
                 f"error in sync_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
@@ -174,40 +186,34 @@ class BaseOperationExecutor:
             exception = exception_
             traceback_str = traceback.format_exc()
 
-        with self.sql_alchemy_db.new_session() as session:
-
-            operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
+        operation_dbm.execution_finish_dt = now_utc_dt()
+        if exception:
+            operation_dbm.status = OperationDBM.Statuses.executed_with_error
+            operation_dbm.error_data = combine_dicts(
+                {
+                    "exception_str": str(exception),
+                    "traceback_str": traceback_str
+                },
+                operation_dbm.error_data
             )
-            operation_dbm.execution_finish_dt = now_utc_dt()
-            if exception:
-                operation_dbm.status = OperationDBM.Statuses.executed_with_error
-                operation_dbm.error_data = combine_dicts(
-                    {
-                        "exception_str": str(exception),
-                        "traceback_str": traceback_str
-                    },
-                    operation_dbm.error_data
-                )
-            else:
-                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+        else:
+            operation_dbm.status = OperationDBM.Statuses.executed_without_error
+        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()
 
-            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(operation_dbm)
 
         self._logger.info(
             f"finish sync_safe_execute_operation, "
@@ -219,21 +225,17 @@ class BaseOperationExecutor:
 
         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:
         if operation_dbm.type == BaseOperationTypes.healthcheck_:
             self._logger.info("healthcheck")
         elif operation_dbm.type == BaseOperationTypes.raise_fake_exception_:
             self._logger.info("raise_fake_exception")
             raise Exception("raise_fake_exception")
-        else:
-            raise Exception(
-                f"unknown operation_dbm.type,"
-                f" operation_dbm.id={operation_dbm.id},"
-                f" operation_dbm.type={operation_dbm.type}"
-            )
         return operation_dbm
 
-    async def async_safe_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+    async def async_safe_execute_operation(
+            self, operation_dbm: OperationDBM, worker: OperationExecutorWorker, session: Session
+    ) -> OperationDBM:
         self._logger.info(
             f"start "
             f"operation_dbm.id={operation_dbm.id}, "
@@ -241,20 +243,21 @@ class BaseOperationExecutor:
             f"operation_dbm.status={operation_dbm.status}"
         )
 
-        with self.sql_alchemy_db.new_session() as session:
-            operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
-            )
-            operation_dbm.execution_start_dt = now_utc_dt()
-            operation_dbm.status = OperationDBM.Statuses.executing
-            session.commit()
-            session.refresh(operation_dbm)
+        operation_dbm.execution_start_dt = now_utc_dt()
+        operation_dbm.status = OperationDBM.Statuses.executing
+        operation_dbm.output_data = combine_dicts(
+            operation_dbm.output_data,
+            {
+                worker.worker_fullname: True
+            }
+        )
+        session.commit()
 
         exception: BaseException | None = None
         traceback_str: str | None = None
 
         try:
-            await self.async_execute_operation(operation_dbm=operation_dbm)
+            await self.async_execute_operation(operation_dbm=operation_dbm, session=session)
         except BaseException as exception_:
             self._logger.error(
                 f"error in async_execute_operation (id={operation_dbm.id}, type={operation_dbm.type})",
@@ -263,40 +266,34 @@ class BaseOperationExecutor:
             exception = exception_
             traceback_str = traceback.format_exc()
 
-        with self.sql_alchemy_db.new_session() as session:
-
-            operation_dbm: OperationDBM = get_operation_by_id(
-                session=session, filter_operation_id=operation_dbm.id, raise_if_not_found=True
+        operation_dbm.execution_finish_dt = now_utc_dt()
+        if exception:
+            operation_dbm.status = OperationDBM.Statuses.executed_with_error
+            operation_dbm.error_data = combine_dicts(
+                {
+                    "exception_str": str(exception),
+                    "traceback_str": traceback_str
+                },
+                operation_dbm.error_data
             )
-            operation_dbm.execution_finish_dt = now_utc_dt()
-            if exception:
-                operation_dbm.status = OperationDBM.Statuses.executed_with_error
-                operation_dbm.error_data = combine_dicts(
-                    {
-                        "exception_str": str(exception),
-                        "traceback_str": traceback_str
-                    },
-                    operation_dbm.error_data
-                )
-            else:
-                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+        else:
+            operation_dbm.status = OperationDBM.Statuses.executed_without_error
+        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()
 
-            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(operation_dbm)
 
         self._logger.info(
             f"finish async_safe_execute_operation, "
@@ -317,53 +314,56 @@ class OperationExecutorWorker(BaseWorker):
             sqlalchemy_db: SQLAlchemyDB,
             operation_executor: BaseOperationExecutor | None = None,
             filter_operation_types: str | list[str] | None = None,
-            timeout_after_run=timedelta(seconds=0.1).total_seconds(),
-            timeout_after_err_in_run=timedelta(seconds=1).total_seconds()
+            startup_funcs: list[Any] | None = None
     ):
-        super().__init__()
+        super().__init__(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
+        if isinstance(filter_operation_types, str):
+            filter_operation_types = [filter_operation_types]
         self.filter_operation_types = filter_operation_types
 
     def sync_on_startup(self):
         self.sqlalchemy_db.init()
+        self.sync_run_startup_funcs()
 
-    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
-        return self.operation_executor.sync_safe_execute_operation(operation_dbm=operation_dbm)
-
-    def sync_run(self):
-        operation_dbm: OperationDBM | None = get_operation_for_execution(
-            sqlalchemy_db=self.sqlalchemy_db,
-            filter_operation_types=self.filter_operation_types
+    def sync_execute_operation(self, operation_dbm: OperationDBM, session: Session) -> OperationDBM:
+        return self.operation_executor.sync_safe_execute_operation(
+            operation_dbm=operation_dbm, worker=self, session=session
         )
-        if not operation_dbm:
-            return
-        self.sync_execute_operation(operation_dbm=operation_dbm)
 
-    def sync_run_on_error(self, exception: BaseException, **kwargs):
-        pass
+    def sync_run(self):
+        with self.sqlalchemy_db.new_session() as session:
+            operation_dbm: OperationDBM | None = get_operation_for_execution(
+                session=session,
+                filter_operation_types=self.filter_operation_types,
+                lock=True
+            )
+            if not operation_dbm:
+                return
+            self.sync_execute_operation(operation_dbm=operation_dbm, session=session)
 
     async def async_on_startup(self):
         self.sqlalchemy_db.init()
+        await self.async_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)
-
-    async def async_run(self):
-        operation_dbm: OperationDBM | None = get_operation_for_execution(
-            sqlalchemy_db=self.sqlalchemy_db,
-            filter_operation_types=self.filter_operation_types
+    async def async_execute_operation(self, operation_dbm: OperationDBM, session: Session) -> OperationDBM:
+        return await self.operation_executor.async_safe_execute_operation(
+            operation_dbm=operation_dbm, worker=self, session=session
         )
-        if not operation_dbm:
-            return
-        await self.async_execute_operation(operation_dbm=operation_dbm)
 
-    async def async_run_on_error(self, exception: BaseException, **kwargs):
-        pass
+    async def async_run(self):
+        with self.sqlalchemy_db.new_session() as session:
+            operation_dbm: OperationDBM | None = get_operation_for_execution(
+                sqlalchemy_db=self.sqlalchemy_db,
+                filter_operation_types=self.filter_operation_types,
+                lock=True
+            )
+            if not operation_dbm:
+                return
+            await self.async_execute_operation(operation_dbm=operation_dbm, session=session)
 
 
 class ScheduledOperation(BaseModel):
@@ -380,20 +380,20 @@ class ScheduledOperationCreatorWorker(BaseWorker):
             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()
+            scheduled_operations: ScheduledOperation | list[ScheduledOperation] | None = None,
+            startup_funcs: list[Any] | None = None
     ):
-        super().__init__()
+        super().__init__(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 = []
+        if isinstance(scheduled_operations, ScheduledOperation):
+            scheduled_operations = [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
@@ -424,6 +424,7 @@ class ScheduledOperationCreatorWorker(BaseWorker):
 
     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
@@ -453,24 +454,25 @@ class ScheduledOperationCreatorWorker(BaseWorker):
             await async_safe_sleep(n=timeout)
 
 
-def every_timedelta_is_time_func(*, td: timedelta) -> Callable:
+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_utc_dt_ = now_utc_dt()
-        if (now_utc_dt_ - last_now_utc_dt) >= td:
-            last_now_utc_dt = 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) -> Callable:
+def between_different_times_is_time_func(
+        *, from_time: time, to_time: time, now_dt_func: Callable = now_utc_dt
+) -> Callable:
     def func() -> bool:
-        now_utc_dt_ = now_utc_dt()
-        if from_time <= now_utc_dt_.time() <= to_time:
+        if from_time <= now_dt_func().time() <= to_time:
             return True
         return False
 

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -189,18 +189,25 @@ class ScheduleUUSTAPIClient:
             return False
         return True
 
-    async def check_all(self):
+    async def check_all(self) -> dict[str, Any]:
+        current_semester = await self.get_current_semester()
+        self._logger.info(f"current_semester: {current_semester}")
+
+        current_week = await self.get_current_week()
+        self._logger.info(f"current_week: {current_week}")
+
         groups = await self.get_groups()
         self._logger.info(f"groups len: {len(groups)}")
 
         teachers = await self.get_teachers()
         self._logger.info(f"teachers len: {len(teachers)}")
 
-        current_semester = await self.get_current_semester()
-        self._logger.info(f"current_semester: {current_semester}")
-
-        current_week = await self.get_current_week()
-        self._logger.info(f"current_week: {current_week}")
+        return {
+            "current_semester": current_semester,
+            "current_week": current_week,
+            "len(groups)": len(groups),
+            "len(teachers)": len(teachers)
+        }
 
 
 def __example():

arpakitlib/ar_settings_util.py

@@ -8,6 +8,8 @@ from pydantic_settings import BaseSettings
 
 from arpakitlib.ar_enumeration_util import Enumeration
 
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
 
 def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]):
     res = ""
@@ -19,29 +21,38 @@ def generate_env_example(settings_class: Union[BaseSettings, type[BaseSettings]]
     return res
 
 
+class ModeTypes(Enumeration):
+    not_prod: str = "not_prod"
+    prod: str = "prod"
+
+
 class SimpleSettings(BaseSettings):
     model_config = ConfigDict(extra="ignore")
 
-    class ModeTypes(Enumeration):
-        not_prod: str = "not_prod"
-        prod: str = "prod"
-
     mode_type: str = ModeTypes.not_prod
 
     @field_validator("mode_type")
     @classmethod
     def validate_mode_type(cls, v: str):
-        cls.ModeTypes.parse_and_validate_values(v)
+        ModeTypes.parse_and_validate_values(v.lower().strip())
         return v
 
     @property
     def is_mode_type_not_prod(self) -> bool:
         return self.mode_type == self.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 == self.ModeTypes.prod
 
+    def raise_if_mode_type_prod(self):
+        if self.is_mode_type_prod:
+            raise ValueError(f"mode type = {self.mode_type}")
+
     @classmethod
     def generate_env_example(cls) -> str:
         return generate_env_example(settings_class=cls)
@@ -52,3 +63,11 @@ class SimpleSettings(BaseSettings):
         with open(filepath, mode="w") as f:
             f.write(env_example)
         return env_example
+
+
+def __example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()

arpakitlib/ar_sqlalchemy_model_util.py

@@ -4,13 +4,13 @@ from datetime import datetime, timedelta
 from typing import Any
 from uuid import uuid4
 
-from sqlalchemy import inspect, INTEGER, TEXT, TIMESTAMP
+from sqlalchemy import inspect, INTEGER, TEXT, TIMESTAMP, func
 from sqlalchemy.dialects.postgresql import JSONB
 from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
 
 from arpakitlib.ar_datetime_util import now_utc_dt
 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
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -34,17 +34,41 @@ class BaseDBM(DeclarativeBase):
         return self._bus_data
 
     def simple_dict(self, *, include_sd_properties: bool = True) -> dict[str, Any]:
-        res = {c.key: getattr(self, c.key) for c in inspect(self).mapper.column_attrs}
+        res = {}
+
+        for c in inspect(self).mapper.column_attrs:
+            value = getattr(self, c.key)
+            if isinstance(value, BaseDBM):
+                res[c.key] = value.simple_dict(include_sd_properties=include_sd_properties)
+            elif isinstance(value, list):
+                res[c.key] = [
+                    item.simple_dict(include_sd_properties=include_sd_properties)
+                    if isinstance(item, BaseDBM) else item
+                    for item in value
+                ]
+            else:
+                res[c.key] = value
 
         if include_sd_properties:
             for attr_name in dir(self):
                 if attr_name.startswith("sdp_") and isinstance(getattr(type(self), attr_name, None), property):
-                    res[attr_name.removesuffix("sdp_")] = getattr(self, attr_name)
+                    prop_name = attr_name.removeprefix("sdp_")
+                    value = getattr(self, attr_name)
+                    if isinstance(value, BaseDBM):
+                        res[prop_name] = value.simple_dict(include_sd_properties=include_sd_properties)
+                    elif isinstance(value, list):
+                        res[prop_name] = [
+                            item.simple_dict(include_sd_properties=include_sd_properties)
+                            if isinstance(item, BaseDBM) else item
+                            for item in value
+                        ]
+                    else:
+                        res[prop_name] = value
 
         return res
 
     def simple_json(self, *, include_sd_properties: bool = True) -> str:
-        return safely_transfer_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
+        return safely_transfer_obj_to_json_str(self.simple_dict(include_sd_properties=include_sd_properties))
 
 
 class SimpleDBM(BaseDBM):
@@ -54,10 +78,12 @@ class SimpleDBM(BaseDBM):
         INTEGER, primary_key=True, autoincrement=True, sort_order=-3, nullable=False
     )
     long_id: Mapped[str] = mapped_column(
-        TEXT, insert_default=generate_default_long_id, unique=True, sort_order=-2, nullable=False
+        TEXT, insert_default=generate_default_long_id, server_default=func.gen_random_uuid(),
+        unique=True, sort_order=-2, nullable=False
     )
     creation_dt: Mapped[datetime] = mapped_column(
-        TIMESTAMP(timezone=True), insert_default=now_utc_dt, index=True, sort_order=-1, nullable=False
+        TIMESTAMP(timezone=True), insert_default=now_utc_dt, server_default=func.now(),
+        index=True, sort_order=-1, nullable=False
     )
 
     def __repr__(self):
@@ -137,6 +163,10 @@ class OperationDBM(SimpleDBM):
             return None
         return self.duration.total_seconds()
 
+    @property
+    def sdp_duration_total_seconds(self) -> float | None:
+        return self.duration_total_seconds
+
 
 def __example():
     pass

arpakitlib/ar_ssh_runner_util.py

@@ -11,7 +11,7 @@ import asyncssh
 import paramiko
 from pydantic import BaseModel
 
-from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -61,7 +61,7 @@ class SSHRunRes(BaseModel):
         }
 
     def simple_json(self) -> str:
-        return safely_transfer_to_json_str(self.simple_dict())
+        return safely_transfer_obj_to_json_str(self.simple_dict())
 
     def __repr__(self) -> str:
         return self.simple_json()