arpakitlib 1.7.213__py3-none-any.whl → 1.7.216__py3-none-any.whl

arpakitlib/ar_arpakit_schedule_uust_api_client_util.py

@@ -3,23 +3,18 @@
 from __future__ import annotations
 
 import asyncio
-import hashlib
-import json
 import logging
 from datetime import timedelta, datetime, time
 from typing import Any
 from urllib.parse import urljoin
 
-import aiohttp
 import cachetools
-from aiohttp import ClientResponse, ClientTimeout, ClientResponseError
+from aiohttp import ClientResponse
 from pydantic import ConfigDict, BaseModel
 
-from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_enumeration_util import Enumeration
+from arpakitlib.ar_http_request_util import async_make_http_request
 from arpakitlib.ar_json_util import safely_transfer_obj_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"
 
@@ -52,14 +47,31 @@ class Months(Enumeration):
 class BaseAPIModel(BaseModel):
     model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
 
-    def simple_json(self) -> str:
-        return safely_transfer_obj_to_json_str(self.model_dump(mode="json"))
+
+class CurrentSemesterAPIModel(BaseAPIModel):
+    id: int
+    long_id: str
+    creation_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
+    value: str
+
+
+class CurrentWeekAPIModel(BaseAPIModel):
+    id: int
+    long_id: str
+    creation_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
+    value: int
 
 
 class GroupAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
     uust_api_id: int
     title: str
     faculty: str | None
@@ -67,20 +79,13 @@ class GroupAPIModel(BaseAPIModel):
     difference_level: int | None = None
     uust_api_data: dict[str, Any]
 
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, arpakit_uust_api_data: dict[str, Any]) -> GroupAPIModel:
-        return GroupAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data}
-        ))
-
 
 class TeacherAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
     uust_api_id: int
     name: str | None
     surname: str | None
@@ -94,20 +99,13 @@ class TeacherAPIModel(BaseAPIModel):
     difference_level: int | None
     uust_api_data: dict[str, Any]
 
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, arpakit_uust_api_data: dict[str, Any]) -> TeacherAPIModel:
-        return TeacherAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data}
-        ))
-
 
 class GroupLessonAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
     uust_api_id: int
     type: str
     title: str
@@ -125,29 +123,6 @@ class GroupLessonAPIModel(BaseAPIModel):
     teacher: TeacherAPIModel | None
     uust_api_data: dict[str, Any]
 
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, arpakit_uust_api_data: dict[str, Any]) -> GroupLessonAPIModel:
-        return GroupLessonAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data},
-            {
-                "group": GroupAPIModel.from_arpakit_uust_api_data(
-                    arpakit_uust_api_data=arpakit_uust_api_data["group"]
-                )
-            },
-            {
-                "teacher": (
-                    TeacherAPIModel.from_arpakit_uust_api_data(
-                        arpakit_uust_api_data=arpakit_uust_api_data["teacher"]
-                    )
-                    if arpakit_uust_api_data["teacher"] is not None
-                    else None
-                )
-            },
-        ))
-
     def compare_type(self, *types: str | list[str]) -> bool:
         type_ = self.type.strip().lower()
         for type__ in types:
@@ -165,8 +140,10 @@ class GroupLessonAPIModel(BaseAPIModel):
 
 class TeacherLessonAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
     uust_api_id: int
     type: str
     title: str
@@ -184,26 +161,6 @@ class TeacherLessonAPIModel(BaseAPIModel):
     groups: list[GroupAPIModel]
     uust_api_data: dict[str, Any]
 
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, arpakit_uust_api_data: dict[str, Any]) -> TeacherLessonAPIModel:
-        return TeacherLessonAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data},
-            {
-                "teacher": TeacherAPIModel.from_arpakit_uust_api_data(
-                    arpakit_uust_api_data=arpakit_uust_api_data["teacher"]
-                )
-            },
-            {
-                "groups": [
-                    GroupAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d)
-                    for d in arpakit_uust_api_data["groups"]
-                ]
-            },
-        ))
-
     def compare_type(self, *types: str | list[str]) -> bool:
         type_ = self.type.strip().lower()
         for type__ in types:
@@ -219,39 +176,6 @@ class TeacherLessonAPIModel(BaseAPIModel):
         return False
 
 
-class CurrentSemesterAPIModel(BaseAPIModel):
-    id: int
-    creation_dt: datetime
-    sync_from_uust_api_dt: datetime
-    value: str
-    raw_value: str
-
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, *, arpakit_uust_api_data: dict[str, Any]) -> CurrentSemesterAPIModel:
-        return CurrentSemesterAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data}
-        ))
-
-
-class CurrentWeekAPIModel(BaseAPIModel):
-    id: int
-    creation_dt: datetime
-    sync_from_uust_api_dt: datetime
-    value: str
-
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, *, arpakit_uust_api_data: dict[str, Any]) -> CurrentWeekAPIModel:
-        return CurrentWeekAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data}
-        ))
-
-
 class WeatherInUfaAPIModel(BaseAPIModel):
     temperature: float
     temperature_feels_like: float
@@ -263,15 +187,6 @@ class WeatherInUfaAPIModel(BaseAPIModel):
     has_snow: bool
     data: dict
 
-    arpakit_uust_api_data: dict[str, Any]
-
-    @classmethod
-    def from_arpakit_uust_api_data(cls, arpakit_uust_api_data: dict[float, Any]) -> WeatherInUfaAPIModel:
-        return WeatherInUfaAPIModel.model_validate(combine_dicts(
-            arpakit_uust_api_data,
-            {"arpakit_uust_api_data": arpakit_uust_api_data}
-        ))
-
 
 class ARPAKITScheduleUUSTAPIClient:
     def __init__(
@@ -280,7 +195,7 @@ class ARPAKITScheduleUUSTAPIClient:
             base_url: str = "https://api.schedule-uust.arpakit.com/api/v1",
             api_key: str | None = "viewer",
             use_cache: bool = False,
-            cache_ttl: int | float | None = timedelta(minutes=10).total_seconds()
+            cache_ttl: timedelta | None = timedelta(minutes=10)
     ):
         self._logger = logging.getLogger(__name__)
         self.api_key = api_key
@@ -290,116 +205,75 @@ class ARPAKITScheduleUUSTAPIClient:
         self.base_url = base_url
         self.headers = {"Content-Type": "application/json"}
         if api_key is not None:
-            self.headers.update({"apikey": api_key})
+            self.headers.update({"apikey": self.api_key})
         self.use_cache = use_cache
         self.cache_ttl = cache_ttl
         if cache_ttl is not None:
-            self.ttl_cache = cachetools.TTLCache(maxsize=100, ttl=cache_ttl)
+            self.ttl_cache = cachetools.TTLCache(maxsize=100, ttl=cache_ttl.total_seconds())
         else:
             self.ttl_cache = None
 
-    def clear_a_s_u_api_client(self):
+    def clear_cache(self):
         if self.ttl_cache is not None:
             self.ttl_cache.clear()
 
-    async def _async_make_request(self, *, method: str = "GET", url: str, **kwargs) -> ClientResponse:
-        max_tries = 7
-        tries = 0
-
-        kwargs["url"] = url
-        kwargs["method"] = method
-        kwargs["timeout"] = ClientTimeout(total=timedelta(seconds=15).total_seconds())
-        kwargs["headers"] = self.headers
-
-        cache_key = (
-            "_async_make_request",
-            hashlib.sha256(json.dumps(kwargs, ensure_ascii=False, default=str).encode()).hexdigest()
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            params: dict[str, Any] | None = None,
+            **kwargs
+    ) -> ClientResponse:
+        response = await async_make_http_request(
+            method=method,
+            url=url,
+            headers=self.headers,
+            params=params,
+            raise_for_status_=True,
+            **kwargs
         )
+        return response
 
-        if self.use_cache and self.ttl_cache is not None:
-            if cache_key in self.ttl_cache:
-                return self.ttl_cache[cache_key]
-
-        while True:
-            tries += 1
-            self._logger.info(f"{method} {url}")
-            try:
-                async with aiohttp.ClientSession() as session:
-                    async with session.request(**kwargs) as response:
-                        await response.read()
-                        if self.use_cache and self.ttl_cache is not None:
-                            self.ttl_cache[cache_key] = response
-                        return response
-            except Exception as err:
-                self._logger.warning(f"{tries}/{max_tries} {err} {method} {url}")
-                if tries >= max_tries:
-                    raise err
-                await async_safe_sleep(timedelta(seconds=0.1).total_seconds())
-                continue
-
-    async def healthcheck(self) -> bool:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "healthcheck"))
-        response.raise_for_status()
+    async def check_auth(self) -> dict[str, Any]:
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "check_auth"))
         json_data = await response.json()
-        return json_data["data"]["healthcheck"]
+        return json_data
 
-    async def is_healthcheck_good(self) -> bool:
-        try:
-            return await self.healthcheck()
-        except ClientResponseError:
-            return False
-
-    async def auth_healthcheck(self) -> bool:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "auth_healthcheck"))
-        response.raise_for_status()
-        json_data = await response.json()
-        return json_data["data"]["auth_healthcheck"]
-
-    async def is_auth_healthcheck_good(self) -> bool:
-        try:
-            return await self.auth_healthcheck()
-        except ClientResponseError:
-            return False
-
-    async def get_required_current_week_value(self) -> int:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "get_current_week"))
-        response.raise_for_status()
+    async def get_current_week(self) -> CurrentWeekAPIModel | None:
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "get_current_week")
+        )
         json_data = await response.json()
-        raise_for_type(json_data["value"], int)
-        return json_data["value"]
+        if json_data is None:
+            return None
+        return CurrentWeekAPIModel.model_validate(json_data)
 
     async def get_current_semester(self) -> CurrentSemesterAPIModel | None:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "get_current_semester"))
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "get_current_semester")
+        )
         json_data = await response.json()
         if json_data is None:
             return None
-        if "error_code" in json_data and json_data["error_code"] == "CURRENT_SEMESTER_NOT_FOUND":
-            return None
-        response.raise_for_status()
-        return CurrentSemesterAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=json_data)
+        return CurrentSemesterAPIModel.model_validate(json_data)
 
-    async def get_current_week(self) -> CurrentWeekAPIModel | None:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "get_current_week"))
+    async def get_weather_in_ufa(self) -> WeatherInUfaAPIModel:
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "get_weather_in_ufa")
+        )
         json_data = await response.json()
-        if json_data is None:
-            return None
-        if "error_code" in json_data and json_data["error_code"] == "CURRENT_WEEK_NOT_FOUND":
-            return None
-        response.raise_for_status()
-        return CurrentWeekAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=json_data)
+        return WeatherInUfaAPIModel.model_validate(json_data)
 
     async def get_log_file_content(self) -> str | None:
-
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "extra/get_log_file"))
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "get_log_file"))
         text_data = await response.text()
         return text_data
 
     async def get_groups(self) -> list[GroupAPIModel]:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "group/get_groups"))
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "get_groups"))
         json_data = await response.json()
-        return [GroupAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
+        return [GroupAPIModel.model_validate(d) for d in json_data]
 
     async def get_group(
             self, *, filter_id: int | None = None, filter_uust_api_id: int | None = None
@@ -409,34 +283,25 @@ class ARPAKITScheduleUUSTAPIClient:
             params["filter_id"] = filter_id
         if filter_uust_api_id is not None:
             params["filter_uust_api_id"] = filter_uust_api_id
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "group/get_group"),
-            params=params
-        )
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "get_group"),
+                                                       params=params)
         json_data = await response.json()
-        if "error_code" in json_data and json_data["error_code"] == "GROUP_NOT_FOUND":
+        if json_data is None:
             return None
-        response.raise_for_status()
-        return GroupAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=json_data)
+        return GroupAPIModel.model_validate(json_data)
 
     async def find_groups(
             self, *, q: str
     ) -> list[GroupAPIModel]:
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "group/find_groups"),
-            params={"q": q.strip()}
-        )
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "find_groups"),
+                                                       params={"q": q.strip()})
         json_data = await response.json()
-        return [GroupAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
+        return [GroupAPIModel.model_validate(d) for d in json_data]
 
     async def get_teachers(self) -> list[TeacherAPIModel]:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "teacher/get_teachers"))
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "get_teachers"))
         json_data = await response.json()
-        return [TeacherAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
+        return [TeacherAPIModel.model_validate(d) for d in json_data]
 
     async def get_teacher(
             self, *, filter_id: int | None = None, filter_uust_api_id: int | None = None
@@ -446,28 +311,37 @@ class ARPAKITScheduleUUSTAPIClient:
             params["filter_id"] = filter_id
         if filter_uust_api_id is not None:
             params["filter_uust_api_id"] = filter_uust_api_id
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "teacher/get_teacher"),
-            params=params
-        )
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "get_teacher"),
+                                                       params=params)
         json_data = await response.json()
-        if "error_code" in json_data and json_data["error_code"] == "TEACHER_NOT_FOUND":
+        if json_data is None:
             return None
-        response.raise_for_status()
-        return TeacherAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=json_data)
+        return TeacherAPIModel.model_validate(json_data)
 
     async def find_teachers(
             self, *, q: str
     ) -> list[TeacherAPIModel]:
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "teacher/find_teachers"),
-            params={"q": q.strip()}
-        )
-        response.raise_for_status()
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "find_teachers"),
+                                                       params={"q": q.strip()})
+        json_data = await response.json()
+        return [TeacherAPIModel.model_validate(d) for d in json_data]
+
+    async def find_any(
+            self, *, q: str
+    ) -> list[TeacherAPIModel | GroupLessonAPIModel]:
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "find_any"),
+                                                       params={"q": q.strip()})
         json_data = await response.json()
-        return [TeacherAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
+
+        results = []
+        for i in json_data:
+            if i.get("entity_type") == "group":
+                results.append(GroupAPIModel.model_validate(i))
+            elif i.get("entity_type") == "teacher":
+                results.append(TeacherAPIModel.model_validate(i))
+            else:
+                pass
+        return results
 
     async def get_group_lessons(
             self,
@@ -480,14 +354,11 @@ class ARPAKITScheduleUUSTAPIClient:
             params["filter_group_id"] = filter_group_id
         if filter_group_uust_api_id is not None:
             params["filter_group_uust_api_id"] = filter_group_uust_api_id
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "group_lesson/get_group_lessons"),
-            params=params
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "get_group_lessons"), params=params
         )
-        response.raise_for_status()
         json_data = await response.json()
-        return [GroupLessonAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
+        return [GroupLessonAPIModel.model_validate(d) for d in json_data]
 
     async def get_teacher_lessons(
             self,
@@ -500,20 +371,11 @@ class ARPAKITScheduleUUSTAPIClient:
             params["filter_teacher_id"] = filter_teacher_id
         if filter_teacher_uust_api_id is not None:
             params["filter_teacher_uust_api_id"] = filter_teacher_uust_api_id
-        response = await self._async_make_request(
-            method="GET",
-            url=urljoin(self.base_url, "teacher_lesson/get_teacher_lessons"),
-            params=params
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "get_teacher_lessons"), params=params
         )
-        response.raise_for_status()
         json_data = await response.json()
-        return [TeacherLessonAPIModel.from_arpakit_uust_api_data(arpakit_uust_api_data=d) for d in json_data]
-
-    async def get_weather_in_ufa(self) -> WeatherInUfaAPIModel:
-        response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "get_weather_in_ufa"))
-        response.raise_for_status()
-        json_data = await response.json()
-        return WeatherInUfaAPIModel.from_arpakit_uust_api_data(json_data)
+        return [TeacherLessonAPIModel.model_validate(d) for d in json_data]
 
 
 def __example():
@@ -521,28 +383,67 @@ def __example():
 
 
 async def __async_example():
-    client = ARPAKITScheduleUUSTAPIClient(api_key="TEST_API_KEY", use_cache=True)
-
-    healthcheck = await client.healthcheck()
-    print(f"Healthcheck: {healthcheck}")
-
-    auth_healthcheck = await client.auth_healthcheck()
-    print(f"Auth Healthcheck: {auth_healthcheck}")
-
-    current_week = await client.get_current_week()
-    print(f"Текущая неделя: {current_week.simple_json() if current_week else 'Не найдено'}")
-
-    current_semester = await client.get_current_semester()
-    print(f"Текущий семестр: {current_semester.simple_json() if current_semester else 'Не найдено'}")
-
-    groups = await client.get_groups()
-    print(f"Группы: {[group.simple_json() for group in groups]}")
-
-    teachers = await client.get_teachers()
-    print(f"Преподаватели: {[teacher.simple_json() for teacher in teachers]}")
-
-    weather = await client.get_weather_in_ufa()
-    print(f"Погода в Уфе: {weather.simple_json()}")
+    client = ARPAKITScheduleUUSTAPIClient(api_key="viewer", use_cache=True)
+
+    print(f"check_auth")
+    print(safely_transfer_obj_to_json_str(await client.check_auth()))
+
+    print(f"get_weather_in_ufa")
+    print(safely_transfer_obj_to_json_str((await client.get_weather_in_ufa()).model_dump()))
+
+    print(f"get_current_week")
+    print(safely_transfer_obj_to_json_str((await client.get_current_week()).model_dump()))
+
+    print(f"get_current_semester")
+    print(safely_transfer_obj_to_json_str((await client.get_current_semester()).model_dump()))
+
+    # Group
+    print(f"get_groups")
+    print(safely_transfer_obj_to_json_str((await client.get_groups())))
+
+    print(f"get_group")
+    if await client.get_group(filter_id=25285, filter_uust_api_id=6674):
+        print(safely_transfer_obj_to_json_str(
+            (await client.get_group(filter_id=25285, filter_uust_api_id=6674)).model_dump()))
+    else:
+        print("Group is none")
+
+    print(f"find_groups")
+    print(safely_transfer_obj_to_json_str((await client.find_groups(q="ПИ-427Б"))))
+
+    # Teacher
+    print(f"get_teachers")
+    print(safely_transfer_obj_to_json_str((await client.get_teachers())))
+
+    print(f"get_teacher")
+    if await client.get_teacher(filter_id=16975, filter_uust_api_id=112978):
+        print(safely_transfer_obj_to_json_str(
+            (await client.get_teacher(filter_id=16975, filter_uust_api_id=112978)).model_dump()))
+    else:
+        print("Teacher is none")
+
+    print(f"find_teachers")
+    print(safely_transfer_obj_to_json_str((await client.find_teachers(q="Казанцев"))))
+
+    # Group Lesson
+    print(f"get_group_lessons")
+    if await client.get_group_lessons(filter_group_id=25285, filter_group_uust_api_id=6674):
+        print(safely_transfer_obj_to_json_str((await client.get_group_lessons(filter_group_id=25285,
+                                                                              filter_group_uust_api_id=6674))))
+    else:
+        print("Group lessons is none")
+
+    # Teacher Lesson
+    print(f"get_teacher_lessons")
+    if await client.get_teacher_lessons(filter_teacher_id=16975, filter_teacher_uust_api_id=112978):
+        print(safely_transfer_obj_to_json_str((await client.get_teacher_lessons(filter_teacher_id=16975,
+                                                                                filter_teacher_uust_api_id=112978))))
+    else:
+        print("Teacher lessons is none")
+
+    # Find Any
+    print(f"find_any")
+    print(safely_transfer_obj_to_json_str((await client.find_any(q="ПИ"))))
 
 
 if __name__ == '__main__':

arpakitlib/ar_fastapi_util.py

@@ -282,7 +282,8 @@ def create_handle_exception(
 def create_story_log_before_response_in_handle_exception(
         *,
         sqlalchemy_db: SQLAlchemyDB,
-        ignore_api_error_code_not_found: bool = True
+        ignore_api_error_codes: list[str] | None = None,
+        ignore_status_codes: list[int] | None = None
 ) -> Callable:
     def func(
             *,
@@ -292,8 +293,12 @@ def create_story_log_before_response_in_handle_exception(
             exception: Exception,
             **kwargs
     ) -> (int, ErrorSO, dict[str, Any]):
-        if ignore_api_error_code_not_found and error_so.error_code == BaseAPIErrorCodes.not_found:
+        if ignore_api_error_codes and error_so.error_code in ignore_api_error_codes:
             return status_code, error_so, kwargs
+
+        if ignore_status_codes and status_code in ignore_status_codes:
+            return status_code, error_so, kwargs
+
         sqlalchemy_db.init()
         traceback_str = "".join(traceback.format_exception(type(exception), exception, exception.__traceback__))
         with sqlalchemy_db.new_session() as session:
@@ -391,7 +396,10 @@ def add_needed_api_router_to_app(*, app: FastAPI):
     async def _():
         return APIJSONResponse(
             status_code=starlette.status.HTTP_200_OK,
-            content=RawDataSO(data={"healthcheck": "healthcheck"})
+            content=RawDataSO(data={
+                "healthcheck": "healthcheck",
+                "is_ok": True
+            })
         )
 
     @api_router.get(
@@ -449,8 +457,8 @@ class BaseAPIAuthData(BaseModel):
     token_string: str | None = None
     api_key_string: str | None = None
 
-    is_token_string_correct: bool | None = None
-    is_api_key_string_correct: bool | None = None
+    is_token_correct: bool | None = None
+    is_api_key_correct: bool | None = None
 
 
 def base_api_auth(
@@ -580,7 +588,7 @@ def base_api_auth(
             )
             if is_async_object(validate_api_key_func_data):
                 validate_api_key_func_data = await validate_api_key_func_data
-            api_auth_data.is_api_key_string_correct = validate_api_key_func_data
+            api_auth_data.is_api_key_correct = validate_api_key_func_data
 
         # token
 
@@ -595,25 +603,27 @@ def base_api_auth(
             )
             if is_async_object(validate_token_func_data):
                 validate_token_func_data_data = await validate_token_func_data
-            api_auth_data.is_token_string_correct = validate_token_func_data_data
+            api_auth_data.is_token_correct = validate_token_func_data_data
 
         # api_key
 
         if require_correct_api_key:
-            if not api_auth_data.is_api_key_string_correct:
+            if not api_auth_data.is_api_key_correct:
                 raise APIException(
                     status_code=starlette.status.HTTP_401_UNAUTHORIZED,
                     error_code=BaseAPIErrorCodes.cannot_authorize,
-                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
+                    error_description="not api_auth_data.is_api_key_correct",
+                    error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump()),
                 )
 
         # token
 
         if require_correct_token:
-            if not api_auth_data.is_token_string_correct:
+            if not api_auth_data.is_token_correct:
                 raise APIException(
                     status_code=starlette.status.HTTP_401_UNAUTHORIZED,
                     error_code=BaseAPIErrorCodes.cannot_authorize,
+                    error_description="not api_auth_data.is_token_correct",
                     error_data=safely_transfer_obj_to_json_str_to_json_obj(api_auth_data.model_dump())
                 )
 

arpakitlib/ar_http_request_util.py

@@ -26,6 +26,7 @@ def sync_make_http_request(
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
+        not_raise_for_statuses: list[int] | None = None,
         timeout_: timedelta | float = timedelta(seconds=15).total_seconds(),
         enable_logging_: bool = False,
         **kwargs
@@ -53,21 +54,25 @@ def sync_make_http_request(
         kwargs["allow_redirects"] = True
 
     if enable_logging_:
-        _logger.info(f"TRY HTTP {method} {url} {params}")
+        _logger.info(f"try http {method} {url} {params}")
 
     while True:
         tries_counter += 1
         try:
             response = requests.request(**kwargs)
             if raise_for_status_:
-                response.raise_for_status()
+                if not_raise_for_statuses and response.status_code in not_raise_for_statuses:
+                    if enable_logging_:
+                        _logger.info(f"ignored status {response.status_code} for http {method} {url} {params}")
+                else:
+                    response.raise_for_status()
             if enable_logging_:
-                _logger.info(f"GOOD TRY HTTP {method} {url} {params}")
+                _logger.info(f"good try http {method} {url} {params}")
             return response
         except BaseException as exception:
             if enable_logging_:
                 _logger.warning(
-                    f"{tries_counter}/{max_tries_}. RETRY {method} {url} {params}, exception={exception}"
+                    f"{tries_counter}/{max_tries_}. retry {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
                 raise exception
@@ -84,6 +89,7 @@ async def async_make_http_request(
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
+        not_raise_for_statuses: list[int] | None = None,
         timeout_: timedelta | None = timedelta(seconds=15),
         enable_logging_: bool = False,
         **kwargs
@@ -106,7 +112,7 @@ async def async_make_http_request(
         proxy_connector = ProxyConnector.from_url(proxy_url_)
 
     if enable_logging_:
-        _logger.info(f"TRY HTTP {method} {url} {params}")
+        _logger.info(f"try http {method} {url} {params}")
 
     while True:
         tries_counter += 1
@@ -114,15 +120,21 @@ async def async_make_http_request(
             async with aiohttp.ClientSession(connector=proxy_connector) as session:
                 async with session.request(**kwargs) as response:
                     if raise_for_status_:
-                        response.raise_for_status()
+                        if not_raise_for_statuses and response.status in not_raise_for_statuses:
+                            if enable_logging_:
+                                _logger.info(
+                                    f"ignored status {response.status} for http {method} {url} {params}"
+                                )
+                        else:
+                            response.raise_for_status()
                     await response.read()
                     if enable_logging_:
-                        _logger.info(f"GOOD TRY HTTP {method} {url} {params}")
+                        _logger.info(f"good try http {method} {url} {params}")
                     return response
         except BaseException as exception:
             if enable_logging_:
                 _logger.warning(
-                    f"{tries_counter}/{max_tries_}. RETRY HTTP {method} {url} {params}, exception={exception}"
+                    f"{tries_counter}/{max_tries_}. retry http {method} {url} {params}, exception={exception}"
                 )
             if tries_counter >= max_tries_:
                 raise exception

arpakitlib/ar_schedule_uust_api_client_util.py

@@ -77,7 +77,8 @@ class ScheduleUUSTAPIClient:
             *,
             method: str = "GET",
             url: str,
-            params: dict[str, Any] | None = None
+            params: dict[str, Any] | None = None,
+            **kwargs
     ) -> ClientResponse:
         response = await async_make_http_request(
             method=method,
@@ -85,7 +86,8 @@ class ScheduleUUSTAPIClient:
             headers=self.headers,
             params=combine_dicts(params, self.auth_params()),
             proxy_url_=self.api_proxy_url,
-            raise_for_status_=True
+            raise_for_status_=True,
+            **kwargs
         )
         json_data = await response.json()
         if "error" in json_data.keys():

{arpakitlib-1.7.213.dist-info → arpakitlib-1.7.216.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: arpakitlib
-Version: 1.7.213
+Version: 1.7.216
 Summary: arpakitlib
 License: Apache-2.0
 Keywords: arpakitlib,arpakit,arpakit-company,arpakitcompany,arpakit_company

{arpakitlib-1.7.213.dist-info → arpakitlib-1.7.216.dist-info}/RECORD

@@ -120,7 +120,7 @@ arpakitlib/ar_aiogram_util.py,sha256=5JPCDZpdBGTE-EIWPRez9amCZAX7XemFIVu5YrQK7Pw
 arpakitlib/ar_api_key_util.py,sha256=E84JlJXiDHtxLQmV8BNHvqNKu_G8-Dox0XxknYJQ37Q,422
 arpakitlib/ar_arpakit_lib_module_util.py,sha256=UEPU8wk29R_bBP_RENnhXYzNbj_RF9FWjowrj_yxWLA,5931
 arpakitlib/ar_arpakit_project_template_util.py,sha256=c7yc8w2IvZGH5hH8eOpL7JuD005hUxZ0GVDcSkJF5iI,3705
-arpakitlib/ar_arpakit_schedule_uust_api_client_util.py,sha256=jGbP6egs2yhgfheyqhM0J-SeM2qp2YrW7dV-u9djv4Q,19223
+arpakitlib/ar_arpakit_schedule_uust_api_client_util.py,sha256=006JstWvs6JTuxRCg3toSNQvtKO0KM5pqyPJa1PRDNA,14998
 arpakitlib/ar_arpakitlib_cli_util.py,sha256=8lhEDxnwMSRX2PGV2xQtQru1AYKSA92SVolol5u7iBk,3154
 arpakitlib/ar_base64_util.py,sha256=aZkg2cZTuAaP2IWeG_LXJ6RO7qhyskVwec-Lks0iM-k,676
 arpakitlib/ar_base_worker_util.py,sha256=Qm_C7PFH5W-LPu1AGX1zp29zbqZ04i71Su1U-eeQBkA,5674
@@ -152,12 +152,12 @@ 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=jpjTmUJKyx8pcOv3UcZsM1r6jPnK5Y7NYDHLm61HQK4,26228
+arpakitlib/ar_fastapi_util.py,sha256=Otm6sa-xB3qUZ7ttp0A52FVEaBN3yRHQx2JKWKYDEGg,26567
 arpakitlib/ar_file_storage_in_dir_util.py,sha256=D3e3rGuHoI6xqAA5mVvEpVVpOWY1jyjNsjj2UhyHRbE,3674
 arpakitlib/ar_file_util.py,sha256=GUdJYm1tUZnYpY-SIPRHAZBHGra8NKy1eYEI0D5AfhY,489
 arpakitlib/ar_func_util.py,sha256=bCuWbSMoFXBaMNhb89sevj2oaXRk4Jk6Qjot8OXMDT4,1319
 arpakitlib/ar_hash_util.py,sha256=Iqy6KBAOLBQMFLWv676boI5sV7atT2B-fb7aCdHOmIQ,340
-arpakitlib/ar_http_request_util.py,sha256=Kp2wKU4wGPsJ6m5sLwCEKWMs3Uqa59SUxhBevU6Gk_s,4328
+arpakitlib/ar_http_request_util.py,sha256=tvYtLiTGxJ0tsoQm4SqBsPmlUn2X0qQPDeetVEIZ7Lk,5078
 arpakitlib/ar_ip_util.py,sha256=aEAa1Hvobh9DWX7cmBAPLqnXSTiKe2hRk-WJaiKMaI8,1009
 arpakitlib/ar_json_db_util.py,sha256=CEyhIU4WuNmX5mqwBVYxUKSdpFelXvWmf_tJ1fuxMSE,7187
 arpakitlib/ar_json_util.py,sha256=wJOsN8N7Rs7r8cTgMDXrmFa1GOkcD-LghqFEYXc8zGA,1083
@@ -172,7 +172,7 @@ arpakitlib/ar_operation_execution_util.py,sha256=uWLDJWYbfsYItUQ48qOSWy4qxCTCFMj
 arpakitlib/ar_parse_command.py,sha256=-s61xcATIsfw1eV_iD3xi-grsitbGzSDoAFc5V0OFy4,3447
 arpakitlib/ar_postgresql_util.py,sha256=1AuLjEaa1Lg4pzn-ukCVnDi35Eg1k91APRTqZhIJAdo,945
 arpakitlib/ar_run_cmd_util.py,sha256=D_rPavKMmWkQtwvZFz-Io5Ak8eSODHkcFeLPzNVC68g,1072
-arpakitlib/ar_schedule_uust_api_client_util.py,sha256=0Ns0mMEXYEkVmP6YTAXHyNcrhNsvCJ8X-G_5XwILhJ4,6855
+arpakitlib/ar_schedule_uust_api_client_util.py,sha256=93d-bc3S0PddqV65lSvmApcSoDV0gqxPVgIaB7zKXfY,6899
 arpakitlib/ar_settings_util.py,sha256=rnoTqbRuhiq7294D4crD5kbnU8-gNWJbwGU_Ls2gJoU,2199
 arpakitlib/ar_sleep_util.py,sha256=OaLtRaJQWMkGjfj_mW1RB2P4RaSWsAIH8LUoXqsH0zM,1061
 arpakitlib/ar_sqladmin_util.py,sha256=6Nv9VQssk9PB0piyuss__soYKdjVhdbIeXIv4AgUxmQ,2660
@@ -183,8 +183,8 @@ arpakitlib/ar_str_util.py,sha256=yU5gOwNXUQaH5b_tM5t6fXUn9oUcv5EQbVnq2wXXIpQ,337
 arpakitlib/ar_type_util.py,sha256=9C3ErtUVs0tAUqtK-foFzjJOykfBOntfCz2IogDOgfA,4134
 arpakitlib/ar_yookassa_api_client_util.py,sha256=sh4fcUkAkdOetFn9JYoTvjcSXP-M1wU04KEY-ECLfLg,5137
 arpakitlib/ar_zabbix_api_client_util.py,sha256=Q-VR4MvoZ9aHwZeYZr9G3LwN-ANx1T5KFmF6pvPM-9M,6402
-arpakitlib-1.7.213.dist-info/LICENSE,sha256=GPEDQMam2r7FSTYqM1mm7aKnxLaWcBotH7UvQtea-ec,11355
-arpakitlib-1.7.213.dist-info/METADATA,sha256=PD-0jkrhtKX-qudtRkX1Nriikr5NLTAoWF0tqHqy84I,3176
-arpakitlib-1.7.213.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-arpakitlib-1.7.213.dist-info/entry_points.txt,sha256=36xqR3PJFT2kuwjkM_EqoIy0qFUDPKSm_mJaI7emewE,87
-arpakitlib-1.7.213.dist-info/RECORD,,
+arpakitlib-1.7.216.dist-info/LICENSE,sha256=GPEDQMam2r7FSTYqM1mm7aKnxLaWcBotH7UvQtea-ec,11355
+arpakitlib-1.7.216.dist-info/METADATA,sha256=Pm0yzZbxaZf_Iu4ROSrnQVVa4RbswNleQQC4PoIU9b0,3176
+arpakitlib-1.7.216.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+arpakitlib-1.7.216.dist-info/entry_points.txt,sha256=36xqR3PJFT2kuwjkM_EqoIy0qFUDPKSm_mJaI7emewE,87
+arpakitlib-1.7.216.dist-info/RECORD,,