arpakitlib 1.5.28__py3-none-any.whl → 1.5.30__py3-none-any.whl

arpakitlib/ar_base_worker.py

@@ -29,28 +29,28 @@ 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:
                     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:
                     sync_safe_sleep(self.timeout_after_err_in_run)
@@ -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:
 
@@ -82,9 +82,9 @@ class BaseWorker(ABC):
 
             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 async_safe_sleep(self.timeout_after_err_in_run)

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,14 +52,6 @@ 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 APIErrorSO(BaseAPISO):
     class APIErrorCodes(EasyEnumeration):
         cannot_authorize = "CANNOT_AUTHORIZE"
@@ -69,6 +66,17 @@ 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,
@@ -163,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,
@@ -237,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:
@@ -245,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(
@@ -284,6 +297,9 @@ def create_fastapi_app(
     return app
 
 
+# ---
+
+
 def __example():
     pass
 

arpakitlib/ar_http_request_util.py

@@ -1,65 +1,97 @@
 # arpakit
 
 import asyncio
-import inspect
 import logging
 from datetime import timedelta
 
 import aiohttp
 import requests
+from aiohttp_socks import ProxyConnector
 
 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 = 9,
+        proxy_url_: str | None = None,
+        raise_for_status_: bool = False,
+        timeout_: timedelta = timedelta(seconds=15).total_seconds(),
+        **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 timeout_ is not None:
+        kwargs["timeout"] = timeout_.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)
+            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 = 9,
+        proxy_url_: str | None = None,
+        raise_for_status_: bool = False,
+        timeout_: timedelta | None = timedelta(seconds=15),
+        **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 timeout_ is not None:
+        kwargs["timeout"] = aiohttp.ClientTimeout(total=timeout_.total_seconds())
+    if "allow_redirects" not 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)
+        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

@@ -1,51 +1,311 @@
-# from datetime import datetime
-# from typing import Any
-#
-# from sqlalchemy import TIMESTAMP, TEXT
-# from sqlalchemy.dialects.postgresql import JSONB
-# from sqlalchemy.orm import Mapped, mapped_column
-#
-# from arpakitlib.ar_enumeration import EasyEnumeration
-# from arpakitlib.ar_sqlalchemy_model_util import SimpleDBM
-#
-#
-# 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"
-#
-#     status: Mapped[str] = mapped_column(
-#         TEXT, index=True, insert_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}"
-#             )
+# 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,16 +3,14 @@
 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_sleep_util import async_safe_sleep
+from arpakitlib.ar_http_request_util import async_make_request
+from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -71,42 +69,21 @@ 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 async_safe_sleep(timedelta(seconds=1).total_seconds())
-                self._logger.warning(f"{tries}/{max_tries} AGAIN GET {url} {params}  proxy={self.api_proxy_url}")
-                continue
+        response = await async_make_request(
+            url=url,
+            method="GET",
+            params=combine_dicts(params, self.auth_params()),
+            proxy_url_=self.api_proxy_url,
+        )
+        json_data = await response.json()
+        raise_for_type(json_data, dict)
+        return json_data
 
     async def get_current_week(self) -> int:
         """
@@ -116,10 +93,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]
 
@@ -131,10 +107,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]
 
@@ -153,42 +128,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
         )
@@ -205,6 +175,12 @@ 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

{arpakitlib-1.5.28.dist-info → arpakitlib-1.5.30.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arpakitlib
-Version: 1.5.28
+Version: 1.5.30
 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.28.dist-info → arpakitlib-1.5.30.dist-info}/RECORD

@@ -9,7 +9,7 @@ arpakitlib/ar_arpakit_lib_module_util.py,sha256=YzobxRG8-QJ1L5r_8wBdL668CwXoQRIM
 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=ZeSXF6EhhlWvZk4mDaDkPmlpTm7o47QW-EhwTmdCbt8,2888
+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
@@ -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=OS3_zeo7it_Yhl0M8c6Uuhn1hjsjlYnAzeK_RGcQekk,9751
+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=nDxJFsljLFurMFEFhhTlBCyEMHBNv9XaTZYhqZFjvfI,2104
+arpakitlib/ar_http_request_util.py,sha256=DooIL24jW6Ouz771TMTTvzDZETBc12R1RBmbXp9vNqg,3129
 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,11 +51,11 @@ 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=msoUrwgBd9HTPsxcuC2jtHgJyQubBNJpvp4RYRTaxko,2139
+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_schedule_uust_api_client.py,sha256=rr80X15Cg4lV5oeqvbHIrG8t09qkzbKrY6v7gK7zT70,6851
+arpakitlib/ar_schedule_uust_api_client.py,sha256=1JGUy6rrjAXdWjeAqiAOQlCAEV3xuc5FUDWfXODKB-A,5770
 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
@@ -63,8 +63,8 @@ arpakitlib/ar_str_util.py,sha256=xSEzmsDvRiZVaxyqFFjcgzpphktCbXg2FHcvsd1DYpA,188
 arpakitlib/ar_type_util.py,sha256=-h-SCsVl11eVo1u4hy2Asn0IfD5TIxmX3Ndug4AvnPE,1761
 arpakitlib/ar_yookassa_api_client.py,sha256=BwsTygaXf35AACVBl_09uYlSD_t-U1OOzbj58OOFT4Q,6480
 arpakitlib/ar_zabbix_util.py,sha256=MTQbmS0QpNCKNOGONNQHf6j7KTZsKGlIbd5rCH0R0WI,6313
-arpakitlib-1.5.28.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
-arpakitlib-1.5.28.dist-info/METADATA,sha256=GjSiqfOwYghOPXb6svQMetAoHSukmBD47BFWRAezyew,2323
-arpakitlib-1.5.28.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
-arpakitlib-1.5.28.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-arpakitlib-1.5.28.dist-info/RECORD,,
+arpakitlib-1.5.30.dist-info/LICENSE,sha256=1jqWIkbnMxDfs_i0SXP5qbV6PHjBr1g8506oW7uPjfg,11347
+arpakitlib-1.5.30.dist-info/METADATA,sha256=-MrOdtGHS5oI_5ygdbJYMxdl9xJQALm6cA60w0Kxbzk,2330
+arpakitlib-1.5.30.dist-info/NOTICE,sha256=wHwmiq3wExfFfgMsE5U5TOBP9_l72ocIG82KurEels0,43
+arpakitlib-1.5.30.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+arpakitlib-1.5.30.dist-info/RECORD,,