arpakitlib 1.5.27__py3-none-any.whl → 1.5.29__py3-none-any.whl

arpakitlib/ar_arpakit_schedule_uust_api_client.py

@@ -6,7 +6,6 @@ import asyncio
 import hashlib
 import json
 import logging
-from asyncio import sleep
 from datetime import timedelta, datetime, time
 from typing import Any
 from urllib.parse import urljoin
@@ -19,6 +18,7 @@ from pydantic import ConfigDict, BaseModel
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration import EasyEnumeration
 from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_sleep_util import async_safe_sleep
 from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -334,7 +334,7 @@ class ARPAKITScheduleUUSTAPIClient:
                 self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
                 if tries >= max_tries:
                     raise err
-                await sleep(timedelta(seconds=0.1).total_seconds())
+                await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
                 continue
 
     async def healthcheck(self) -> bool:

arpakitlib/ar_base_worker.py

@@ -6,7 +6,7 @@ from abc import ABC
 from datetime import timedelta
 from typing import Any
 
-from arpakitlib.ar_safe_sleep import safe_sleep
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -29,31 +29,31 @@ class BaseWorker(ABC):
         self._logger.exception(exception)
 
     def sync_safe_run(self):
-        self._logger.info(f"sync_safe_run")
+        self._logger.info(f"start sync_safe_run")
 
-        self._logger.info("sync_on_startup starts")
+        self._logger.info("start sync_on_startup ")
         self.sync_on_startup()
-        self._logger.info("sync_on_startup ends")
+        self._logger.info("finish sync_on_startup")
 
         while True:
 
             try:
 
-                self._logger.info("sync_run starts")
+                self._logger.info("start sync_run")
                 self.sync_run()
-                self._logger.info("sync_run ends")
+                self._logger.info("finish sync_run")
 
                 if self.timeout_after_run is not None:
-                    safe_sleep(self.timeout_after_run)
+                    sync_safe_sleep(self.timeout_after_run)
 
             except BaseException as exception:
 
-                self._logger.info("sync_run_on_error starts")
+                self._logger.info("start sync_run_on_error")
                 self.sync_run_on_error(exception=exception, kwargs={})
-                self._logger.info("sync_run_on_error ends")
+                self._logger.info("start sync_run_on_error")
 
                 if self.timeout_after_err_in_run is not None:
-                    safe_sleep(self.timeout_after_err_in_run)
+                    sync_safe_sleep(self.timeout_after_err_in_run)
 
     async def async_on_startup(self):
         pass
@@ -65,11 +65,11 @@ class BaseWorker(ABC):
         self._logger.exception(exception)
 
     async def async_safe_run(self):
-        self._logger.info(f"async_safe_run starts")
+        self._logger.info(f"start async_safe_run")
 
-        self._logger.info("async_on_startup starts")
+        self._logger.info("start async_on_startup")
         await self.async_on_startup()
-        self._logger.info("async_on_startup ends")
+        self._logger.info("start async_on_startup")
 
         while True:
 
@@ -78,16 +78,16 @@ class BaseWorker(ABC):
                 await self.async_run()
 
                 if self.timeout_after_run is not None:
-                    await asyncio.sleep(self.timeout_after_run)
+                    await async_safe_sleep(self.timeout_after_run)
 
             except BaseException as exception:
 
-                self._logger.info("async_run_on_error starts")
+                self._logger.info("start async_run_on_error")
                 await self.async_run_on_error(exception=exception, kwargs={})
-                self._logger.info("async_run_on_error ends")
+                self._logger.info("finish async_run_on_error")
 
                 if self.timeout_after_err_in_run is not None:
-                    await asyncio.sleep(self.timeout_after_err_in_run)
+                    await async_safe_sleep(self.timeout_after_err_in_run)
 
 
 def __example():

arpakitlib/ar_dream_ai_api_client.py

@@ -2,7 +2,6 @@
 
 import asyncio
 import logging
-from asyncio import sleep
 from datetime import timedelta
 from urllib.parse import urljoin
 
@@ -12,6 +11,7 @@ from pydantic import ConfigDict, BaseModel
 
 from arpakitlib.ar_base64_util import convert_base64_string_to_bytes
 from arpakitlib.ar_json_util import safely_transfer_to_json_str
+from arpakitlib.ar_sleep_util import async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -72,7 +72,7 @@ class DreamAIAPIClient:
                 self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
                 if tries >= max_tries:
                     raise err
-                await sleep(timedelta(seconds=0.1).total_seconds())
+                await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
                 continue
 
     async def healthcheck(self) -> bool:

arpakitlib/ar_fastapi_util.py

@@ -1,5 +1,7 @@
 # arpakit
 
+from __future__ import annotations
+
 import asyncio
 import logging
 import os.path
@@ -24,6 +26,9 @@ _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 _logger = logging.getLogger(__name__)
 
 
+# ---
+
+
 class BaseAPISchema(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
@@ -47,22 +52,13 @@ class BaseAPISO(BaseAPISchema):
     pass
 
 
-class APIJSONResponse(fastapi.responses.JSONResponse):
-    def __init__(self, *, content: BaseAPISO, status_code: int = starlette.status.HTTP_200_OK):
-        super().__init__(
-            content=content.model_dump(mode="json"),
-            status_code=status_code
-        )
-
-
-class APIErrorCodes(EasyEnumeration):
-    cannot_authorize = "CANNOT_AUTHORIZE"
-    unknown_error = "UNKNOWN_ERROR"
-    error_in_request = "ERROR_IN_REQUEST"
-    not_found = "NOT_FOUND"
-
-
 class APIErrorSO(BaseAPISO):
+    class APIErrorCodes(EasyEnumeration):
+        cannot_authorize = "CANNOT_AUTHORIZE"
+        unknown_error = "UNKNOWN_ERROR"
+        error_in_request = "ERROR_IN_REQUEST"
+        not_found = "NOT_FOUND"
+
     has_error: bool = True
     error_code: str | None = None
     error_code_specification: str | None = None
@@ -70,12 +66,23 @@ class APIErrorSO(BaseAPISO):
     error_data: dict[str, Any] = {}
 
 
+# ---
+
+
+class APIJSONResponse(fastapi.responses.JSONResponse):
+    def __init__(self, *, content: BaseAPISO, status_code: int = starlette.status.HTTP_200_OK):
+        super().__init__(
+            content=content.model_dump(mode="json"),
+            status_code=status_code
+        )
+
+
 class APIException(fastapi.exceptions.HTTPException):
     def __init__(
             self,
             *,
             status_code: int = starlette.status.HTTP_400_BAD_REQUEST,
-            error_code: str | None = APIErrorCodes.unknown_error,
+            error_code: str | None = APIErrorSO.APIErrorCodes.unknown_error,
             error_code_specification: str | None = None,
             error_description: str | None = None,
             error_data: dict[str, Any] | None = None
@@ -113,7 +120,7 @@ def from_exception_to_api_json_response(
 
     easy_api_error_so = APIErrorSO(
         has_error=True,
-        error_code=APIErrorCodes.unknown_error
+        error_code=APIErrorSO.APIErrorCodes.unknown_error
     )
 
     status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
@@ -124,11 +131,11 @@ def from_exception_to_api_json_response(
     elif isinstance(exception, starlette.exceptions.HTTPException):
         status_code = exception.status_code
         if status_code in (starlette.status.HTTP_403_FORBIDDEN, starlette.status.HTTP_401_UNAUTHORIZED):
-            easy_api_error_so.error_code = APIErrorCodes.cannot_authorize
+            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.cannot_authorize
         elif status_code == starlette.status.HTTP_404_NOT_FOUND:
-            easy_api_error_so.error_code = APIErrorCodes.not_found
+            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.not_found
         else:
-            easy_api_error_so.error_code = APIErrorCodes.unknown_error
+            easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.unknown_error
         if (
                 isinstance(exception.detail, dict)
                 or isinstance(exception.detail, list)
@@ -141,12 +148,12 @@ def from_exception_to_api_json_response(
 
     elif isinstance(exception, fastapi.exceptions.RequestValidationError):
         status_code = starlette.status.HTTP_422_UNPROCESSABLE_ENTITY
-        easy_api_error_so.error_code = APIErrorCodes.error_in_request
+        easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.error_in_request
         easy_api_error_so.error_data["raw"] = str(exception.errors()) if exception.errors() else {}
 
     else:
         status_code = starlette.status.HTTP_500_INTERNAL_SERVER_ERROR
-        easy_api_error_so.error_code = APIErrorCodes.unknown_error
+        easy_api_error_so.error_code = APIErrorSO.APIErrorCodes.unknown_error
         easy_api_error_so.error_data["raw"] = str(exception)
         _logger.exception(exception)
 
@@ -164,6 +171,9 @@ def from_exception_to_api_json_response(
     )
 
 
+# ---
+
+
 def add_exception_handler_to_fastapi_app(*, fastapi_app: FastAPI, api_handle_exception_: Callable) -> FastAPI:
     fastapi_app.add_exception_handler(
         exc_class_or_status_code=Exception,
@@ -238,7 +248,8 @@ class BaseAPIStartupEvent:
         self._logger = logging.getLogger(self.__class__.__name__)
 
     async def on_startup(self, *args, **kwargs):
-        self._logger.info("on_startup")
+        self._logger.info("on_startup starts")
+        self._logger.info("on_startup ends")
 
 
 class BaseAPIShutdownEvent:
@@ -246,15 +257,16 @@ class BaseAPIShutdownEvent:
         self._logger = logging.getLogger(self.__class__.__name__)
 
     async def on_shutdown(self, *args, **kwargs):
-        self._logger.info("on_shutdown")
+        self._logger.info("on_shutdown starts")
+        self._logger.info("on_shutdown ends")
 
 
 def create_fastapi_app(
         *,
         title: str,
         description: str | None = None,
-        api_startup_event: BaseAPIStartupEvent | None = None,
-        api_shutdown_event: BaseAPIShutdownEvent | None = None,
+        api_startup_event: BaseAPIStartupEvent | None = BaseAPIStartupEvent(),
+        api_shutdown_event: BaseAPIShutdownEvent | None = BaseAPIShutdownEvent(),
         api_handle_exception_: Callable | None = simple_api_handle_exception
 ):
     app = FastAPI(
@@ -285,6 +297,9 @@ def create_fastapi_app(
     return app
 
 
+# ---
+
+
 def __example():
     pass
 

arpakitlib/ar_http_request_util.py

@@ -1,66 +1,96 @@
 # arpakit
 
 import asyncio
-import inspect
 import logging
 from datetime import timedelta
 
 import aiohttp
 import requests
+from aiohttp_socks import ProxyConnector
 
-from arpakitlib.ar_safe_sleep import safe_sleep
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
+_logger = logging.getLogger(__name__)
 
-def sync_make_request(*, method: str, url: str, **kwargs) -> requests.Response:
-    _logger = logging.getLogger(inspect.currentframe().f_code.co_name)
 
-    max_tries = 7
-    tries = 0
+def sync_make_request(
+        *,
+        method: str = "GET",
+        url: str,
+        max_tries: int = 7,
+        proxy_url_: str | None = None,
+        raise_for_status_: bool = False,
+        **kwargs
+) -> requests.Response:
+    tries_counter = 0
 
     kwargs["method"] = method
     kwargs["url"] = url
     if "timeout" not in kwargs:
         kwargs["timeout"] = (timedelta(seconds=15).total_seconds(), timedelta(seconds=15).total_seconds())
+    if proxy_url_:
+        kwargs["proxies"] = {
+            "http": proxy_url_,
+            "https": proxy_url_
+        }
+    if "allow_redirects" not in kwargs:
+        kwargs["allow_redirects"] = True
 
     while True:
-        tries += 1
-        _logger.info(f"{method} {url}")
+        tries_counter += 1
+        _logger.info(f"{method} {url} {kwargs.get('params')}")
         try:
-            return requests.request(**kwargs)
-        except Exception as err:
-            _logger.warning(f"{tries}/{max_tries} {method} {url} {err}")
-            if tries >= max_tries:
-                raise Exception(err)
-            safe_sleep(timedelta(seconds=0.1).total_seconds())
+            response = requests.request(**kwargs)
+            if raise_for_status_:
+                response.raise_for_status()
+            return response
+        except BaseException as exception:
+            _logger.warning(f"{tries_counter}/{max_tries} {method} {url} {exception}")
+            if tries_counter >= max_tries:
+                raise exception
+            sync_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 
 
-async def async_make_request(*, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
-    _logger = logging.getLogger(inspect.currentframe().f_code.co_name)
-
-    max_tries = 7
-    tries = 0
+async def async_make_request(
+        *,
+        method: str = "GET",
+        url: str,
+        max_tries: int = 7,
+        proxy_url_: str | None = None,
+        raise_for_status_: bool = False,
+        **kwargs
+) -> aiohttp.ClientResponse:
+    tries_counter = 0
 
     kwargs["method"] = method
     kwargs["url"] = url
     if "timeout" not in kwargs:
         kwargs["timeout"] = aiohttp.ClientTimeout(total=timedelta(seconds=15).total_seconds())
+    if "allow_redirects" in kwargs:
+        kwargs["allow_redirects"] = True
+
+    proxy_connector: ProxyConnector | None = None
+    if proxy_url_:
+        proxy_connector = ProxyConnector.from_url(proxy_url_)
 
     while True:
-        tries += 1
-        _logger.info(f"{method} {url}")
+        tries_counter += 1
+        _logger.info(f"{method} {url} {kwargs.get('params')}")
         try:
-            async with aiohttp.ClientSession() as session:
+            async with aiohttp.ClientSession(connector=proxy_connector) as session:
                 async with session.request(**kwargs) as response:
+                    if raise_for_status_:
+                        response.raise_for_status()
                     await response.read()
                     return response
-        except Exception as err:
-            _logger.warning(f"{tries}/{max_tries} {method} {url} {err}")
-            if tries >= max_tries:
-                raise Exception(err)
-            await asyncio.sleep(timedelta(seconds=0.1).total_seconds())
+        except BaseException as exception:
+            _logger.warning(f"{tries_counter}/{max_tries} {method} {url} {exception}")
+            if tries_counter >= max_tries:
+                raise exception
+            await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
             continue
 
 

arpakitlib/ar_operation_execution_util.py

@@ -0,0 +1,311 @@
+# arpakit
+
+from __future__ import annotations
+
+import logging
+import traceback
+from datetime import datetime, timedelta
+from typing import Any
+
+from sqlalchemy import TIMESTAMP, TEXT, asc
+from sqlalchemy.dialects.postgresql import JSONB
+from sqlalchemy.orm import Mapped, mapped_column, Session
+
+from arpakitlib.ar_base_worker import BaseWorker
+from arpakitlib.ar_datetime_util import now_utc_dt
+from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_easy_sqlalchemy_util import EasySQLAlchemyDB
+from arpakitlib.ar_enumeration import EasyEnumeration
+from arpakitlib.ar_fastapi_util import BaseAPISO
+from arpakitlib.ar_sqlalchemy_model_util import SimpleDBM
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class OperationDBM(SimpleDBM):
+    __tablename__ = "operation"
+
+    class Statuses(EasyEnumeration):
+        waiting_for_execution = "waiting_for_execution"
+        executing = "executing"
+        executed_without_error = "executed_without_error"
+        executed_with_error = "executed_with_error"
+
+    class Types(EasyEnumeration):
+        healthcheck_ = "healthcheck"
+        raise_fake_exception = "raise_fake_exception"
+
+    status: Mapped[str] = mapped_column(
+        TEXT, index=True, insert_default=Statuses.waiting_for_execution,
+        server_default=Statuses.waiting_for_execution, nullable=False
+    )
+    type: Mapped[str] = mapped_column(
+        TEXT, index=True, insert_default=Types.healthcheck_, nullable=False
+    )
+    execution_start_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
+    execution_finish_dt: Mapped[datetime | None] = mapped_column(TIMESTAMP(timezone=True), nullable=True)
+    input_data: Mapped[dict[str, Any]] = mapped_column(
+        JSONB,
+        insert_default={},
+        server_default="{}",
+        nullable=False
+    )
+    output_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
+    error_data: Mapped[dict[str, Any]] = mapped_column(JSONB, insert_default={}, server_default="{}", nullable=False)
+
+    def raise_if_executed_with_error(self):
+        if self.status == self.Statuses.executed_with_error:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) executed with error, error_data={self.error_data}"
+            )
+
+    def raise_if_error_data(self):
+        if self.status == self.Statuses.executed_with_error:
+            raise Exception(
+                f"Operation (id={self.id}, type={self.type}) has error_data, error_data={self.error_data}"
+            )
+
+    @property
+    def duration(self) -> timedelta | None:
+        if self.execution_start_dt is None or self.execution_finish_dt is None:
+            return None
+        return self.execution_finish_dt - self.execution_start_dt
+
+    @property
+    def duration_total_seconds(self) -> float | None:
+        if self.duration is None:
+            return None
+        return self.duration.total_seconds()
+
+
+class OperationSO(BaseAPISO):
+    id: int
+    long_id: str
+    creation_dt: datetime
+    execution_start_dt: datetime | None
+    execution_finish_dt: datetime | None
+    status: str
+    type: str
+    input_data: dict[str, Any]
+    output_data: dict[str, Any]
+    error_data: dict[str, Any]
+    duration_total_seconds: float | None
+
+
+def get_operation_for_execution(
+        *,
+        easy_sql_alchemy_db: EasySQLAlchemyDB,
+        filter_operation_type: str | None = None
+) -> OperationDBM | None:
+    with easy_sql_alchemy_db.new_session() as session:
+        query = (
+            session
+            .query(OperationDBM)
+            .filter(OperationDBM.status == OperationDBM.Statuses.waiting_for_execution)
+        )
+        if filter_operation_type:
+            query = query.filter(OperationDBM.type == filter_operation_type)
+        query = query.order_by(asc(OperationDBM.creation_dt))
+        operation_dbm: OperationDBM | None = query.first()
+    return operation_dbm
+
+
+def get_operation_by_id(
+        *,
+        session: Session,
+        filter_operation_id: int,
+        strict: bool = False
+) -> OperationDBM | None:
+    query = (
+        session
+        .query(OperationDBM)
+        .filter(OperationDBM.id == filter_operation_id)
+    )
+    if strict:
+        return query.one()
+    else:
+        return query.one_or_none()
+
+
+class BaseOperationExecutor:
+    def __init__(self, *, easy_sql_alchemy_db: EasySQLAlchemyDB):
+        self._logger = logging.getLogger(self.__class__.__name__)
+        self.easy_sql_alchemy_db = easy_sql_alchemy_db
+
+    async def async_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+            self._logger.info("healthcheck")
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception:
+            self._logger.info("raise_fake_exception")
+            raise Exception("raise_fake_exception")
+        else:
+            raise ValueError(f"unknown operation.type = {operation_dbm.type}")
+        return operation_dbm
+
+    async def async_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}"
+        )
+
+        with self.easy_sql_alchemy_db.new_session() as session:
+            operation_dbm: OperationDBM = get_operation_by_id(
+                session=session, filter_operation_id=operation_dbm.id, strict=True
+            )
+            operation_dbm.execution_start_dt = now_utc_dt()
+            operation_dbm.status = OperationDBM.Statuses.executing
+            session.commit()
+            session.refresh(operation_dbm)
+
+        exception: BaseException | None = None
+        traceback_str: str | None = None
+
+        try:
+            await self.async_execute_operation(operation_dbm=operation_dbm)
+        except BaseException as exception_:
+            self._logger.exception(exception_)
+            exception = exception_
+            traceback_str = traceback.format_exc()
+
+        with self.easy_sql_alchemy_db.new_session() as session:
+            operation_dbm: OperationDBM = get_operation_by_id(
+                session=session, filter_operation_id=operation_dbm.id, strict=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(exception), "traceback_str": traceback_str},
+                    operation_dbm.error_data
+                )
+            else:
+                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+            session.commit()
+            session.refresh(operation_dbm)
+
+        self._logger.info(
+            f"finish async_safe_execute_operation"
+            f", operation_dbm.id={operation_dbm.id}"
+            f", operation_dbm.type={operation_dbm.type}"
+        )
+
+        return operation_dbm
+
+    def sync_execute_operation(self, operation_dbm: OperationDBM) -> OperationDBM:
+        if operation_dbm.type == OperationDBM.Types.healthcheck_:
+            self._logger.info("healthcheck")
+        elif operation_dbm.type == OperationDBM.Types.raise_fake_exception:
+            self._logger.info("raise_fake_exception")
+            raise Exception("raise_fake_exception")
+        else:
+            raise ValueError(f"unknown operation.type = {operation_dbm.type}")
+        return operation_dbm
+
+    def sync_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}"
+        )
+
+        with self.easy_sql_alchemy_db.new_session() as session:
+            operation_dbm: OperationDBM = get_operation_by_id(
+                session=session, filter_operation_id=operation_dbm.id, strict=True
+            )
+            operation_dbm.execution_start_dt = now_utc_dt()
+            operation_dbm.status = OperationDBM.Statuses.executing
+            session.commit()
+            session.refresh(operation_dbm)
+
+        exception: BaseException | None = None
+        traceback_str: str | None = None
+
+        try:
+            self.sync_execute_operation(operation_dbm=operation_dbm)
+        except BaseException as exception_:
+            self._logger.exception(exception_)
+            exception = exception_
+            traceback_str = traceback.format_exc()
+
+        with self.easy_sql_alchemy_db.new_session() as session:
+            operation_dbm: OperationDBM = get_operation_by_id(
+                session=session, filter_operation_id=operation_dbm.id, strict=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(exception), "traceback_str": traceback_str},
+                    operation_dbm.error_data
+                )
+            else:
+                operation_dbm.status = OperationDBM.Statuses.executed_without_error
+            session.commit()
+            session.refresh(operation_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}"
+        )
+
+        return operation_dbm
+
+
+class ExecuteOperationWorker(BaseWorker):
+
+    def __init__(
+            self,
+            *,
+            easy_sql_alchemy_db: EasySQLAlchemyDB,
+            operation_executor: BaseOperationExecutor,
+            need_operation_type: str | None = None
+    ):
+        super().__init__()
+        self.easy_sql_alchemy_db = easy_sql_alchemy_db
+        self.timeout_after_run = timedelta(seconds=0.1).total_seconds()
+        self.timeout_after_err_in_run = timedelta(seconds=1).total_seconds()
+        self.operation_executor = operation_executor
+        self.need_operation_type = need_operation_type
+
+    async def async_on_startup(self):
+        self.easy_sql_alchemy_db.init()
+
+    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(
+            easy_sql_alchemy_db=self.easy_sql_alchemy_db,
+            filter_operation_type=self.need_operation_type
+        )
+
+        if not operation_dbm:
+            return
+
+        await self.async_execute_operation(operation_dbm=operation_dbm)
+
+    async def async_run_on_error(self, exception: BaseException, kwargs: dict[str, Any]):
+        self._logger.exception(exception)
+
+    def sync_on_startup(self):
+        self.easy_sql_alchemy_db.init()
+
+    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(
+            easy_sql_alchemy_db=self.easy_sql_alchemy_db,
+            filter_operation_type=self.need_operation_type
+        )
+
+        if not operation_dbm:
+            return
+
+        self.sync_execute_operation(operation_dbm=operation_dbm)
+
+    def sync_run_on_error(self, exception: BaseException, kwargs: dict[str, Any]):
+        self._logger.exception(exception)

arpakitlib/ar_schedule_uust_api_client.py

@@ -3,15 +3,15 @@
 import asyncio
 import hashlib
 import logging
-from datetime import timedelta, datetime
-from typing import Optional, Any
+from datetime import datetime
+from typing import Any
 
-import aiohttp
 import pytz
-from aiohttp import ClientTimeout
-from aiohttp_socks import ProxyConnector
 
 from arpakitlib.ar_dict_util import combine_dicts
+from arpakitlib.ar_http_request_util import async_make_request
+from arpakitlib.ar_logging_util import setup_normal_logging
+from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -70,42 +70,23 @@ class ScheduleUUSTAPIClient:
             password_first_part + datetime.now(tz=pytz.timezone("Asia/Yekaterinburg")).strftime("%Y-%m-%d")
         )
 
-    async def _async_get_request(
+    async def _async_make_http_get_request(
             self,
             *,
             url: str,
-            params: Optional[dict] = None
+            params: dict | None = None
     ) -> dict[str, Any]:
-        max_tries = 7
-        tries = 0
-
-        while True:
-            self._logger.info(f"GET {url} {params} proxy={self.api_proxy_url}")
-
-            tries += 1
-
-            connector = (
-                ProxyConnector.from_url(self.api_proxy_url)
-                if self.api_proxy_url is not None
-                else None
-            )
-
-            try:
-                async with aiohttp.ClientSession(connector=connector) as session:
-                    async with session.get(
-                            url=url,
-                            params=params,
-                            timeout=ClientTimeout(total=timedelta(seconds=15).total_seconds())
-                    ) as response:
-                        response.raise_for_status()
-                        return await response.json()
-            except Exception as err:
-                self._logger.warning(f"{tries}/{max_tries} {err} GET {url} {params}  proxy={self.api_proxy_url}")
-                if tries >= max_tries:
-                    raise err
-                await asyncio.sleep(timedelta(seconds=1).total_seconds())
-                self._logger.warning(f"{tries}/{max_tries} AGAIN GET {url} {params}  proxy={self.api_proxy_url}")
-                continue
+        params = combine_dicts(self.auth_params(), params)
+        response = await async_make_request(
+            url=url,
+            method="GET",
+            params=params,
+            proxy_url_=self.api_proxy_url,
+            max_tries=9
+        )
+        json_data = await response.json()
+        raise_for_type(json_data, dict)
+        return json_data
 
     async def get_current_week(self) -> int:
         """
@@ -115,10 +96,9 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        params = combine_dicts(self.auth_params(), {"ask": "get_current_week"})
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
-            params=params
+            params={"ask": "get_current_week"}
         )
         return json_data["data"][0]
 
@@ -130,10 +110,9 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        params = combine_dicts(self.auth_params(), {"ask": "get_current_semestr"})
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
-            params=params
+            params={"ask": "get_current_semestr"}
         )
         return json_data["data"][0]
 
@@ -152,42 +131,37 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        params = combine_dicts(self.auth_params(), {"ask": "get_group_list"})
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
-            params=params
+            params={"ask": "get_group_list"}
         )
         return list(json_data["data"].values())
 
     async def get_group_lessons(self, group_id: int, semester: str | None = None) -> list[dict[str, Any]]:
-        params = combine_dicts(
-            self.auth_params(),
-            {
-                "ask": "get_group_schedule",
-                "id": group_id
-            }
-        )
+        params = {
+            "ask": "get_group_schedule",
+            "id": group_id
+        }
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
             params=params
         )
         return json_data["data"]
 
     async def get_teachers(self) -> list[dict[str, Any]]:
-        params = combine_dicts(self.auth_params(), {"ask": "get_teacher_list"})
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
-            params=params
+            params={"ask": "get_teacher_list"}
         )
         return list(json_data["data"].values())
 
     async def get_teacher_lessons(self, teacher_id: int, semester: str | None = None) -> list[dict[str, Any]]:
-        params = combine_dicts(self.auth_params(), {"ask": "get_teacher_schedule", "id": teacher_id})
+        params = {"ask": "get_teacher_schedule", "id": teacher_id}
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_get_request(
+        json_data = await self._async_make_http_get_request(
             url=self.api_url,
             params=params
         )
@@ -204,13 +178,24 @@ class ScheduleUUSTAPIClient:
             return False
         return True
 
+    async def check_all(self):
+        await self.get_groups()
+        await self.get_teachers()
+        await self.get_current_semester()
+        await self.get_current_week()
+
 
 def __example():
     pass
 
 
 async def __async_example():
-    pass
+    setup_normal_logging()
+    client = ScheduleUUSTAPIClient(
+        api_login="arpakit",
+        api_password_first_part="bAEb2wXJNNZ8"
+    )
+    await client.check_all()
 
 
 if __name__ == '__main__':

arpakitlib/ar_sleep_util.py

@@ -0,0 +1,68 @@
+# arpakit
+
+import asyncio
+import logging
+import math
+from time import sleep
+
+from asyncpg.pgproto.pgproto import timedelta
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+_logger = logging.getLogger(__name__)
+
+
+def sync_safe_sleep(n: timedelta | float | int):
+    _logger.info(f"sync_safe_sleep ({n}) starts")
+
+    if isinstance(n, timedelta):
+        n = n.total_seconds()
+    elif isinstance(n, int):
+        n = float(n)
+    elif isinstance(n, float):
+        n = n
+    else:
+        raise TypeError(f"n={n}, type={type(n)}, n: timedelta | float | int")
+
+    n: float = n
+
+    frac, int_part = math.modf(n)
+    for i in range(int(int_part)):
+        sleep(1)
+    sleep(frac)
+
+    _logger.info(f"sync_safe_sleep ({n}) ends")
+
+
+async def async_safe_sleep(n: timedelta | float | int):
+    _logger.info(f"async_safe_sleep ({n}) starts")
+
+    if isinstance(n, timedelta):
+        n = n.total_seconds()
+    elif isinstance(n, int):
+        n = float(n)
+    elif isinstance(n, float):
+        n = n
+    else:
+        raise TypeError(f"n={n}, type={type(n)}, n: timedelta | float | int")
+
+    n: float = n
+
+    _logger.info(f"sleep_time ({n}) starts")
+    await asyncio.sleep(n)
+    _logger.info(f"sleep_time ({n}) ends")
+
+    _logger.info(f"async_safe_sleep ({n}) ends")
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

arpakitlib/ar_sqlalchemy_model_util.py

@@ -42,3 +42,6 @@ class SimpleDBM(BaseDBM):
     creation_dt: Mapped[datetime] = mapped_column(
         TIMESTAMP(timezone=True), insert_default=now_utc_dt, index=True, nullable=False
     )
+
+    def __repr__(self):
+        return f"{self.__class__.__name__.removesuffix('DBM')} (id={self.id})"

arpakitlib/ar_yookassa_api_client.py

@@ -13,7 +13,7 @@ import requests
 
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration import EasyEnumeration
-from arpakitlib.ar_safe_sleep import safe_sleep
+from arpakitlib.ar_sleep_util import sync_safe_sleep, async_safe_sleep
 from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
@@ -63,7 +63,7 @@ class YookassaAPIClient:
                 self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
                 if tries >= max_tries:
                     raise YookassaAPIException(err)
-                safe_sleep(timedelta(seconds=0.1).total_seconds())
+                sync_safe_sleep(timedelta(seconds=0.1).total_seconds())
                 continue
 
     async def _async_make_request(self, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
@@ -90,7 +90,7 @@ class YookassaAPIClient:
                 self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
                 if tries >= max_tries:
                     raise YookassaAPIException(err)
-                await asyncio.sleep(timedelta(seconds=0.1).total_seconds())
+                await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
                 continue
 
     def sync_create_payment(

{arpakitlib-1.5.27.dist-info → arpakitlib-1.5.29.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arpakitlib
-Version: 1.5.27
+Version: 1.5.29
 Summary: arpakitlib
 Home-page: https://github.com/ARPAKIT-Company/arpakitlib
 License: Apache-2.0
@@ -33,7 +33,7 @@ Requires-Dist: pymongo (>=4.10.1,<5.0.0)
 Requires-Dist: pytz (>=2024.2,<2025.0)
 Requires-Dist: pyzabbix (>=1.3.1,<2.0.0)
 Requires-Dist: redis (>=5.2.0,<6.0.0)
-Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: requests[socks] (>=2.32.3,<3.0.0)
 Requires-Dist: sqladmin (>=0.20.1,<0.21.0)
 Requires-Dist: sqlalchemy (>=2.0.36,<3.0.0)
 Requires-Dist: twine (>=6.0.1,<7.0.0)

{arpakitlib-1.5.27.dist-info → arpakitlib-1.5.29.dist-info}/RECORD

@@ -6,14 +6,14 @@ arpakitlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 arpakitlib/ar_additional_model_util.py,sha256=Eq7pvVUgO2L3gYBocm-pP9TrztTb8VNCp7LdRMml-F8,237
 arpakitlib/ar_aiogram_util.py,sha256=IA48PRMIJrPLMhFA0Eb2vQpLcqm98o9tKfC3pDy8qsI,12022
 arpakitlib/ar_arpakit_lib_module_util.py,sha256=YzobxRG8-QJ1L5r_8wBdL668CwXoQRIM1Cpec1o2WBc,5447
-arpakitlib/ar_arpakit_schedule_uust_api_client.py,sha256=mswH5a7ek-xs-smtTTaRTPPmeoXkrAaoDoi-u6HS0BM,18205
+arpakitlib/ar_arpakit_schedule_uust_api_client.py,sha256=V8n5XxkrsZo7ASNAepD0mqgRtI7qIleCDgk7WAmdLW8,18244
 arpakitlib/ar_arpakitlib_info.py,sha256=cvgrLnEznmYkCAg1adbY46ATjD6GJd-Yk8PTgOPjpKM,248
 arpakitlib/ar_base64_util.py,sha256=aZkg2cZTuAaP2IWeG_LXJ6RO7qhyskVwec-Lks0iM-k,676
-arpakitlib/ar_base_worker.py,sha256=NqZKJIij-7rmisPR2k4pl3nEnWCBpMqcvUDYXYIW1_Q,2849
+arpakitlib/ar_base_worker.py,sha256=Y6yRFp1nhhTyv-TeGDao-3q4ICVVJ2zVsKdIlHdiGSI,2897
 arpakitlib/ar_cache_file.py,sha256=m73_vU6bMjXsIurSPO9VCLcHsiHk8ITFS0LNjfI_8Uw,3471
 arpakitlib/ar_datetime_util.py,sha256=Xe1NiT9oPQzNSG7RVRkhukhbg4i-hhS5ImmV7sPUc8o,971
 arpakitlib/ar_dict_util.py,sha256=cF5LQJ6tLqyGoEXfDljMDZrikeZoWPw7CgINHIFGvXM,419
-arpakitlib/ar_dream_ai_api_client.py,sha256=73iNDQc5x4fSiWNNuniNPlAwju4kVI_pL3dbMf30Jyg,3990
+arpakitlib/ar_dream_ai_api_client.py,sha256=hDPL9wbG4MjIuhn2ed6qepueogANIkt-NddhhiPUv0Y,4029
 arpakitlib/ar_easy_sqlalchemy_util.py,sha256=HuKRBD4XoxeZ5tpXlDTol5Y6AOzuCBluJQHfyRjlRqs,3224
 arpakitlib/ar_encrypt_and_decrypt_util.py,sha256=GhWnp7HHkbhwFVVCzO1H07m-5gryr4yjWsXjOaNQm1Y,520
 arpakitlib/ar_enumeration.py,sha256=6KUJYOabHDPLfdigBVN0ZI4ZOUJh8TkL0g4o92Hke2I,2254
@@ -36,11 +36,11 @@ arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.css,sha256=jzPZlgJTFwSdSphk9C
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.css.map,sha256=5wq8eXMLU6Zxb45orZPL1zAsBFJReFw6GjYqGpUX3hg,262650
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.js,sha256=ffrLZHHEQ_g84A-ul3yWa10Kk09waOAxHcQXPuZuavg,339292
 arpakitlib/ar_fastapi_static/swagger-ui/swagger-ui.js.map,sha256=9UhIW7MqCOZPAz1Sl1IKfZUuhWU0p-LJqrnjjJD9Xhc,1159454
-arpakitlib/ar_fastapi_util.py,sha256=ugnVVI0zFRoeCkoGQKMNEGxaM8ly5wBAyHajPZk04CE,9655
+arpakitlib/ar_fastapi_util.py,sha256=zru-le-J139KpLlPeo9DUjMuDygh4tR2GhAJjlr7ROs,9959
 arpakitlib/ar_file_storage_in_dir.py,sha256=D3e3rGuHoI6xqAA5mVvEpVVpOWY1jyjNsjj2UhyHRbE,3674
 arpakitlib/ar_generate_env_example.py,sha256=WseNlk_So6mTVQ2amMuigWYV4ZVmd940POvXtodoYj0,325
 arpakitlib/ar_hash_util.py,sha256=Iqy6KBAOLBQMFLWv676boI5sV7atT2B-fb7aCdHOmIQ,340
-arpakitlib/ar_http_request_util.py,sha256=ZVM8p5XWrEj7rhlFLrUMvGcS6M8O-GlFHqOsrUXQf2I,2073
+arpakitlib/ar_http_request_util.py,sha256=jx0ggOVXLvsh2hVUE7tasWaEsUnXbO0WS8-rJb0Y6BU,3063
 arpakitlib/ar_ip_util.py,sha256=aEAa1Hvobh9DWX7cmBAPLqnXSTiKe2hRk-WJaiKMaI8,1009
 arpakitlib/ar_json_db.py,sha256=CEyhIU4WuNmX5mqwBVYxUKSdpFelXvWmf_tJ1fuxMSE,7187
 arpakitlib/ar_json_util.py,sha256=S8CskZ3uoYuJGCy1GhQ8Ikhn-fxXk-9JpLUbBvXADqI,833
@@ -51,19 +51,20 @@ arpakitlib/ar_logging_util.py,sha256=c5wX2FLqCzb4aLckLVhIJ7go52rJQ4GN9dIkJ6KMc3o
 arpakitlib/ar_mongodb_util.py,sha256=2ECkTnGAZ92qxioL-fmN6R4yZOSr3bXdXLWTzT1C3vk,4038
 arpakitlib/ar_need_type_util.py,sha256=qCRSWlSgx-3yU0NRHZDQ5lCOmuZKcz2Na3py9nr6hJM,1618
 arpakitlib/ar_openai_util.py,sha256=d5Aj1O2yo_zYLZCLeOLvuveYYxA2jGOqhMs1oUbuVk8,1210
+arpakitlib/ar_operation_execution_util.py,sha256=i-GDXFCAXrPwi-juH1sKWNsIPQZ036QxyC4n9oN_RWw,11802
 arpakitlib/ar_parse_command.py,sha256=qpr2OwG3Bf7DFiL9S3iWgtbvtE80RSC35E5zFJvjG1I,2714
 arpakitlib/ar_postgresql_util.py,sha256=SAHEmAyMkZe516uk2gS830v_Wn2kRUZUYNcTNwmgXJk,1160
 arpakitlib/ar_run_cmd.py,sha256=D_rPavKMmWkQtwvZFz-Io5Ak8eSODHkcFeLPzNVC68g,1072
-arpakitlib/ar_safe_sleep.py,sha256=b7vj6BrKLgYlUQup2t3qiwx0cA_jrkIX9MZjaraW0bM,409
-arpakitlib/ar_schedule_uust_api_client.py,sha256=DUke6CQFKKcQQJQnpZc5JPPmQpsOJba4K-6FYKyBj-0,6794
-arpakitlib/ar_sqlalchemy_model_util.py,sha256=OZCciQk-rCBcAzSf4In27Mik9GmeHPKN7CZr3FA3umk,1275
+arpakitlib/ar_schedule_uust_api_client.py,sha256=hShokh3uJuTPC78-AMW2mv1WSJMy4cAuVDJ4sLaoqMs,6043
+arpakitlib/ar_sleep_util.py,sha256=9ZN4Qo4eZ_q3hjM7vNBQjFRcH-9-sqv3QLSjnxVJE90,1405
+arpakitlib/ar_sqlalchemy_model_util.py,sha256=3zscvaloi9XY1NR70rJ4-jJlFUIqhmTbQ9wdvK-Yjf8,1379
 arpakitlib/ar_ssh_runner.py,sha256=jlnss4V4pziBN1rBzoK_lDiWm6nMOqGXfa6NFJSKH-Y,6796
 arpakitlib/ar_str_util.py,sha256=xSEzmsDvRiZVaxyqFFjcgzpphktCbXg2FHcvsd1DYpA,1885
 arpakitlib/ar_type_util.py,sha256=-h-SCsVl11eVo1u4hy2Asn0IfD5TIxmX3Ndug4AvnPE,1761
-arpakitlib/ar_yookassa_api_client.py,sha256=HOzhTggH_-BligDyqRg2fwhxYf8ULTnnFZkyn0PNdQM,6449
+arpakitlib/ar_yookassa_api_client.py,sha256=BwsTygaXf35AACVBl_09uYlSD_t-U1OOzbj58OOFT4Q,6480
 arpakitlib/ar_zabbix_util.py,sha256=MTQbmS0QpNCKNOGONNQHf6j7KTZsKGlIbd5rCH0R0WI,6313
-arpakitlib-1.5.27.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
-arpakitlib-1.5.27.dist-info/METADATA,sha256=ZJZ7aI5UygBLSoJmcxRN9Ib1Ec1_3Iu9lc7yNJ3CwfA,2323
-arpakitlib-1.5.27.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
-arpakitlib-1.5.27.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-arpakitlib-1.5.27.dist-info/RECORD,,
+arpakitlib-1.5.29.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
+arpakitlib-1.5.29.dist-info/METADATA,sha256=BeKeVptEUesxJ2rNi-UpFTY2XuRep1w_3p1dXPN_4SM,2330
+arpakitlib-1.5.29.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
+arpakitlib-1.5.29.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+arpakitlib-1.5.29.dist-info/RECORD,,

arpakitlib/ar_safe_sleep.py

@@ -1,25 +0,0 @@
-# arpakit
-
-import logging
-import math
-from time import sleep
-
-_ARPAKIT_LIB_MODULE_VERSION = "3.0"
-
-_logger = logging.getLogger(__name__)
-
-
-def safe_sleep(sleep_time: float | int):
-    _logger.info(f"sleep_time={sleep_time}")
-    frac, int_part = math.modf(sleep_time)
-    for i in range(int(int_part)):
-        sleep(1)
-    sleep(frac)
-
-
-def __example():
-    pass
-
-
-if __name__ == '__main__':
-    __example()