arpakitlib 1.6.91__tar.gz → 1.6.93__tar.gz

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: arpakitlib
-Version: 1.6.91
+Version: 1.6.93
 Summary: arpakitlib
 Home-page: https://github.com/ARPAKIT-Company/arpakitlib
 License: Apache-2.0

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/arpakitlib/ar_aiogram_util.py

@@ -326,19 +326,20 @@ class BaseTransmittedTgBotData(BaseModel):
     model_config = ConfigDict(extra="ignore", arbitrary_types_allowed=True, from_attributes=True)
 
 
-def create_aiogram_tg_bot(*, tg_bot_token: str, tg_bot_proxy_url: str | None = None) -> Bot:
-    session: AiohttpSession | None = None
+def create_aiogram_tg_bot(*, tg_bot_token: str, tg_bot_proxy_url: str | None = None, **kwargs) -> Bot:
+    kwargs["token"] = tg_bot_token
+
     if tg_bot_proxy_url:
-        session = AiohttpSession(proxy=tg_bot_proxy_url)
-    tg_bot = Bot(
-        token=tg_bot_token,
-        default=DefaultBotProperties(
+        kwargs["session"] = AiohttpSession(proxy=tg_bot_proxy_url)
+
+    if kwargs.get("default") is None:
+        kwargs["default"] = DefaultBotProperties(
             parse_mode=ParseMode.HTML,
             disable_notification=False,
             link_preview_is_disabled=True
-        ),
-        session=session
-    )
+        )
+
+    tg_bot = Bot(**kwargs)
 
     return tg_bot
 

arpakitlib-1.6.93/arpakitlib/ar_dream_ai_api_client_util.py

@@ -0,0 +1,96 @@
+# arpakit
+
+import asyncio
+import logging
+from typing import Any
+from urllib.parse import urljoin
+
+from aiohttp import ClientResponse
+from pydantic import ConfigDict, BaseModel
+
+from arpakitlib.ar_base64_util import convert_base64_string_to_bytes
+from arpakitlib.ar_http_request_util import async_make_http_request
+
+_ARPAKIT_LIB_MODULE_VERSION = "3.0"
+
+
+class BaseAPIModel(BaseModel):
+    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
+
+
+class GenerateImageFromNumberResApiModel(BaseAPIModel):
+    image_filename: str
+    image_url: str
+    image_base64: str
+
+    def save_file(self, filepath: str):
+        with open(filepath, mode="wb") as f:
+            f.write(convert_base64_string_to_bytes(base64_string=self.image_base64))
+        return filepath
+
+
+class DreamAIAPIClient:
+    def __init__(
+            self,
+            *,
+            base_url: str = "https://api.dream_ai.arpakit.com/api/v1",
+            api_key: str | None = "1"
+    ):
+        self._logger = logging.getLogger(__name__)
+        self.api_key = api_key
+        base_url = base_url.strip()
+        if not base_url.endswith("/"):
+            base_url += "/"
+        self.base_url = base_url
+        self.headers = {"Content-Type": "application/json"}
+        if api_key is not None:
+            self.headers.update({"apikey": api_key})
+
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            params: dict[str, Any] | None = None
+    ) -> ClientResponse:
+        response = await async_make_http_request(
+            method=method,
+            url=url,
+            params=params,
+            headers=self.headers,
+        )
+        response.raise_for_status()
+        return response
+
+    async def healthcheck(self) -> bool:
+        response = await self._async_make_http_request(method="GET", url=urljoin(self.base_url, "healthcheck"))
+        json_data = await response.json()
+        return json_data["data"]["healthcheck"] == "healthcheck"
+
+    async def is_healthcheck_good(self) -> bool:
+        try:
+            return await self.healthcheck()
+        except Exception as exception:
+            self._logger.error(exception)
+            return False
+
+    async def generate_image_from_number(self, *, number: int) -> GenerateImageFromNumberResApiModel:
+        response = await self._async_make_http_request(
+            method="GET", url=urljoin(self.base_url, "generate_image_from_number"),
+            params={"number": number}
+        )
+        json_data = await response.json()
+        return GenerateImageFromNumberResApiModel.model_validate(json_data)
+
+
+def __example():
+    pass
+
+
+async def __async_example():
+    pass
+
+
+if __name__ == '__main__':
+    __example()
+    asyncio.run(__async_example())

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/arpakitlib/ar_fastapi_util.py

@@ -579,7 +579,8 @@ def create_fastapi_app(
         shutdown_api_events: list[BaseShutdownAPIEvent] | None = None,
         transmitted_api_data: BaseTransmittedAPIData = BaseTransmittedAPIData(),
         main_api_router: APIRouter = simple_api_router_for_testing(),
-        contact: dict[str, Any] | None = None
+        contact: dict[str, Any] | None = None,
+        media_dirpath: str | None = None
 ):
     if contact is None:
         contact = _DEFAULT_CONTACT
@@ -603,6 +604,9 @@ def create_fastapi_app(
         contact=contact
     )
 
+    if media_dirpath is not None:
+        app.mount("/media", StaticFiles(directory=media_dirpath), name="media")
+
     app.state.transmitted_api_data = transmitted_api_data
 
     add_cors_to_app(app=app)

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/arpakitlib/ar_http_request_util.py

@@ -3,6 +3,7 @@
 import asyncio
 import logging
 from datetime import timedelta
+from typing import Any
 
 import aiohttp
 import requests
@@ -20,6 +21,8 @@ def sync_make_http_request(
         *,
         method: str = "GET",
         url: str,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
@@ -34,13 +37,17 @@ def sync_make_http_request(
 
     kwargs["method"] = method
     kwargs["url"] = url
-    if timeout_ is not None:
-        kwargs["timeout"] = timeout_.total_seconds()
+    if headers is not None:
+        kwargs["headers"] = headers
+    if params is not None:
+        kwargs["params"] = params
     if proxy_url_:
         kwargs["proxies"] = {
             "http": proxy_url_,
             "https": proxy_url_
         }
+    if timeout_ is not None:
+        kwargs["timeout"] = timeout_.total_seconds()
     if "allow_redirects" not in kwargs:
         kwargs["allow_redirects"] = True
 
@@ -64,6 +71,8 @@ async def async_make_http_request(
         *,
         method: str = "GET",
         url: str,
+        headers: dict[str, Any] | None = None,
+        params: dict[str, Any] | None = None,
         max_tries_: int = 9,
         proxy_url_: str | None = None,
         raise_for_status_: bool = False,
@@ -74,6 +83,10 @@ async def async_make_http_request(
 
     kwargs["method"] = method
     kwargs["url"] = url
+    if headers is not None:
+        kwargs["headers"] = headers
+    if params is not None:
+        kwargs["params"] = params
     if timeout_ is not None:
         kwargs["timeout"] = aiohttp.ClientTimeout(total=timeout_.total_seconds())
     if "allow_redirects" not in kwargs:

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/arpakitlib/ar_schedule_uust_api_client_util.py

@@ -3,14 +3,14 @@
 import asyncio
 import hashlib
 import logging
-from datetime import datetime, timedelta
+from datetime import datetime
 from typing import Any
 
 import pytz
+from aiohttp import ClientResponse
 
 from arpakitlib.ar_dict_util import combine_dicts
 from arpakitlib.ar_http_request_util import async_make_http_request
-from arpakitlib.ar_type_util import raise_for_type
 
 _ARPAKIT_LIB_MODULE_VERSION = "3.0"
 
@@ -72,25 +72,22 @@ class ScheduleUUSTAPIClient:
     def generate_v2_token(self) -> str:
         return self.generate_new_v2_token(password_first_part=self.api_password_first_part)
 
-    async def _async_make_http_get_request(
+    async def _async_make_http_request(
             self,
             *,
+            method: str = "GET",
             url: str,
-            params: dict | None = None
-    ) -> dict[str, Any]:
+            params: dict[str, Any] | None = None
+    ) -> ClientResponse:
         response = await async_make_http_request(
+            method=method,
             url=url,
-            method="GET",
             params=combine_dicts(params, self.auth_params()),
             proxy_url_=self.api_proxy_url,
-            max_tries_=9,
-            timeout_=timedelta(seconds=15),
             raise_for_status_=True,
             headers=self.headers
         )
-        json_data = await response.json()
-        raise_for_type(json_data, dict)
-        return json_data
+        return response
 
     async def get_current_week(self) -> int:
         """
@@ -100,10 +97,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_current_week"}
         )
+        json_data = await response.json()
         return json_data["data"][0]
 
     async def get_current_semester(self) -> str:
@@ -114,10 +112,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_current_semestr"}
         )
+        json_data = await response.json()
         return json_data["data"][0]
 
     async def get_groups(self) -> list[dict[str, Any]]:
@@ -135,10 +134,11 @@ class ScheduleUUSTAPIClient:
         }
         """
 
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_group_list"}
         )
+        json_data = await response.json()
         return list(json_data["data"].values())
 
     async def get_group_lessons(self, group_id: int, semester: str | None = None) -> list[dict[str, Any]]:
@@ -148,27 +148,30 @@ class ScheduleUUSTAPIClient:
         }
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params=params
         )
+        json_data = await response.json()
         return json_data["data"]
 
     async def get_teachers(self) -> list[dict[str, Any]]:
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params={"ask": "get_teacher_list"}
         )
+        json_data = await response.json()
         return list(json_data["data"].values())
 
     async def get_teacher_lessons(self, teacher_id: int, semester: str | None = None) -> list[dict[str, Any]]:
         params = {"ask": "get_teacher_schedule", "id": teacher_id}
         if semester is not None:
             params["semester"] = semester
-        json_data = await self._async_make_http_get_request(
+        response = await self._async_make_http_request(
             url=self.api_url,
             params=params
         )
+        json_data = await response.json()
         return json_data["data"]
 
     async def check_conn(self):

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/arpakitlib/ar_yookassa_api_client_util.py

@@ -42,7 +42,7 @@ class YookassaAPIClient:
         self.headers = {"Content-Type": "application/json"}
         self._logger = logging.getLogger(self.__class__.__name__)
 
-    def _sync_make_request(
+    def _sync_make_http_request(
             self,
             *,
             method: str,
@@ -53,10 +53,10 @@ class YookassaAPIClient:
             kwargs["headers"] = {}
         kwargs["headers"] = combine_dicts(self.headers, kwargs["headers"])
         kwargs["auth"] = (self.shop_id, self.secret_key)
-        kwargs["timeout_"] = timedelta(seconds=3)
         return sync_make_http_request(
             method=method,
             url=url,
+            timeout_=timedelta(seconds=3),
             **kwargs
         )
 
@@ -88,7 +88,7 @@ class YookassaAPIClient:
         if idempotence_key is None:
             idempotence_key = str(uuid.uuid4())
 
-        response = self._sync_make_request(
+        response = self._sync_make_http_request(
             method="POST",
             url="https://api.yookassa.ru/v3/payments",
             headers={"Idempotence-Key": idempotence_key},
@@ -104,7 +104,7 @@ class YookassaAPIClient:
     def sync_get_payment(self, payment_id: str) -> Optional[dict[str, Any]]:
         raise_for_type(payment_id, str)
 
-        response = self._sync_make_request(
+        response = self._sync_make_http_request(
             method="GET",
             url=f"https://api.yookassa.ru/v3/payments/{payment_id}",
             headers=self.headers
@@ -119,15 +119,21 @@ class YookassaAPIClient:
 
         return json_data
 
-    async def async_make_request(self, method: str, url: str, **kwargs) -> aiohttp.ClientResponse:
+    async def _async_make_http_request(
+            self,
+            *,
+            method: str = "GET",
+            url: str,
+            **kwargs
+    ) -> aiohttp.ClientResponse:
         if "headers" not in kwargs:
             kwargs["headers"] = {}
         kwargs["headers"] = combine_dicts(self.headers, kwargs["headers"])
         kwargs["auth"] = aiohttp.BasicAuth(login=str(self.shop_id), password=self.secret_key)
-        kwargs["timeout_"] = timedelta(seconds=3)
         return await async_make_http_request(
             method=method,
             url=url,
+            timeout_=timedelta(seconds=3),
             **kwargs
         )
 
@@ -157,7 +163,7 @@ class YookassaAPIClient:
         if idempotence_key is None:
             idempotence_key = str(uuid.uuid4())
 
-        response = await self.async_make_request(
+        response = await self._async_make_http_request(
             method="POST",
             url="https://api.yookassa.ru/v3/payments",
             headers={"Idempotence-Key": idempotence_key},
@@ -173,7 +179,7 @@ class YookassaAPIClient:
     async def async_get_payment(self, payment_id: str) -> Optional[dict[str, Any]]:
         raise_for_type(payment_id, str)
 
-        response = await self.async_make_request(
+        response = await self._async_make_http_request(
             method="GET",
             url=f"https://api.yookassa.ru/v3/payments/{payment_id}",
         )

{arpakitlib-1.6.91 → arpakitlib-1.6.93}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "arpakitlib"
-version = "1.6.91"
+version = "1.6.93"
 description = "arpakitlib"
 authors = ["arpakit <arpakit@gmail.com>", "arpakit_support <support@arpakit.com>"]
 license = "Apache License 2.0"

arpakitlib-1.6.91/arpakitlib/ar_dream_ai_api_client_util.py

@@ -1,122 +0,0 @@
-# arpakit
-
-import asyncio
-import logging
-from datetime import timedelta
-from urllib.parse import urljoin
-
-import aiohttp
-from aiohttp import ClientResponseError, ClientResponse, ClientTimeout
-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"
-
-
-class BaseAPIModel(BaseModel):
-    model_config = ConfigDict(extra="forbid", arbitrary_types_allowed=True, from_attributes=True)
-
-    def simple_json(self) -> str:
-        return safely_transfer_to_json_str(self.model_dump(mode="json"))
-
-
-class GenerateImageFromNumberResApiModel(BaseAPIModel):
-    image_filename: str
-    image_url: str
-    image_base64: str
-
-    def save_file(self, filepath: str):
-        with open(filepath, mode="wb") as f:
-            f.write(convert_base64_string_to_bytes(base64_string=self.image_base64))
-        return filepath
-
-
-class DreamAIAPIClient:
-    def __init__(
-            self,
-            *,
-            base_url: str = "https://api.dream_ai.arpakit.com/api/v1",
-            api_key: str | None = None
-    ):
-        self._logger = logging.getLogger(__name__)
-        self.api_key = api_key
-        base_url = base_url.strip()
-        if not base_url.endswith("/"):
-            base_url += "/"
-        self.base_url = base_url
-        self.headers = {"Content-Type": "application/json"}
-        if api_key is not None:
-            self.headers.update({"apikey": api_key})
-
-    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
-
-        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()
-                        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:
-        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 generate_image_from_number(self, *, number: int) -> GenerateImageFromNumberResApiModel:
-        response = await self._async_make_request(
-            method="GET", url=urljoin(self.base_url, "generate_image_from_number"),
-            params={"number": number}
-        )
-        response.raise_for_status()
-        json_data = await response.json()
-        return GenerateImageFromNumberResApiModel.model_validate(json_data)
-
-
-def __example():
-    pass
-
-
-async def __async_example():
-    pass
-
-
-if __name__ == '__main__':
-    __example()
-    asyncio.run(__async_example())