arpakitlib 1.7.214__tar.gz → 1.7.215__tar.gz

{arpakitlib-1.7.214 → arpakitlib-1.7.215}/PKG-INFO

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

{arpakitlib-1.7.214 → arpakitlib-1.7.215}/arpakitlib/ar_arpakit_schedule_uust_api_client_util.py

@@ -3,21 +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_enumeration_util import Enumeration
-from arpakitlib.ar_sleep_util import async_safe_sleep
-from arpakitlib.ar_type_util import raise_for_type
+from arpakitlib.ar_http_request_util import async_make_http_request
+from arpakitlib.ar_json_util import safely_transfer_obj_to_json_str
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -53,17 +50,20 @@ class BaseAPIModel(BaseModel):
 
 class CurrentSemesterAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
+    entity_type: str
+    actualization_dt: datetime
     value: str
-    raw_value: str
 
 
 class CurrentWeekAPIModel(BaseAPIModel):
     id: int
+    long_id: str
     creation_dt: datetime
-    sync_from_uust_api_dt: datetime
-    value: str
+    entity_type: str
+    actualization_dt: datetime
+    value: int
 
 
 class GroupAPIModel(BaseAPIModel):
@@ -209,91 +209,47 @@ class ARPAKITScheduleUUSTAPIClient:
         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_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()
-        json_data = await response.json()
-        return json_data["data"]["healthcheck"]
-
-    async def is_healthcheck_good(self) -> bool:
-        try:
-            return await self.healthcheck()
-        except ClientResponseError:
-            return False
-
-    async def auth_healthcheck(self) -> bool:
+    async def check_auth(self) -> dict[str, Any]:
         response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "check_auth"))
-        response.raise_for_status()
         json_data = await response.json()
-        return json_data["data"]["auth_healthcheck"]
+        return json_data
 
-    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:
+    async def get_current_week(self) -> CurrentWeekAPIModel | None:
         response = await self._async_make_request(method="GET", url=urljoin(self.base_url, "get_current_week"))
-        response.raise_for_status()
         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"))
         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_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:
 
@@ -416,40 +372,26 @@ class ARPAKITScheduleUUSTAPIClient:
         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)
-
 
 def __example():
     pass
 
 
 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 'Не найдено'}")
+    client = ARPAKITScheduleUUSTAPIClient(api_key="viewer", use_cache=True)
 
-    current_semester = await client.get_current_semester()
-    print(f"Текущий семестр: {current_semester.simple_json() if current_semester else 'Не найдено'}")
+    print(f"check_auth")
+    print(safely_transfer_obj_to_json_str(await client.check_auth()))
+    print()
 
-    groups = await client.get_groups()
-    print(f"Группы: {[group.simple_json() for group in groups]}")
+    print(f"get_weather_in_ufa")
+    print(safely_transfer_obj_to_json_str((await client.get_weather_in_ufa()).model_dump()))
 
-    teachers = await client.get_teachers()
-    print(f"Преподаватели: {[teacher.simple_json() for teacher in teachers]}")
+    print(f"get_current_week")
+    print(safely_transfer_obj_to_json_str((await client.get_current_week()).model_dump()))
 
-    weather = await client.get_weather_in_ufa()
-    print(f"Погода в Уфе: {weather.simple_json()}")
+    print(f"get_current_semester")
+    print(safely_transfer_obj_to_json_str((await client.get_current_semester()).model_dump()))
 
 
 if __name__ == '__main__':

{arpakitlib-1.7.214 → arpakitlib-1.7.215}/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-1.7.214 → arpakitlib-1.7.215}/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.214 → arpakitlib-1.7.215}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "arpakitlib"
-version = "1.7.214"
+version = "1.7.215"
 description = "arpakitlib"
 authors = [
     { name = "arpakit", email = "arpakit@gmail.com" },