b24api 0.3.9__tar.gz → 0.4.0__tar.gz

{b24api-0.3.9/b24api.egg-info → b24api-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b24api
-Version: 0.3.9
+Version: 0.4.0
 Summary: Bitrix24 API
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: fast-depends>=2.4.12
 Requires-Dist: httpx[http2]>=0.28.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: retry>=0.9.2
+Requires-Dist: tenacity>=9.1.2
 Dynamic: license-file
 
 # API client for Bitrix24

{b24api-0.3.9 → b24api-0.4.0}/b24api/api.py

@@ -1,49 +1,50 @@
 import contextlib
-import json
 import logging
 from collections.abc import Generator, Iterable
-from functools import partial
 from itertools import chain, islice
 from operator import itemgetter
+from typing import Any
 
 import h2.exceptions
 import httpx
 from fast_depends import inject
+from httpx import Client
 from pydantic import ValidationError
-from retry import retry
+from tenacity import Retrying, before_sleep_log, retry_if_exception_type, stop_after_attempt, wait_exponential
 
 from b24api.entity import ApiTypes, BatchResult, ErrorResponse, ListRequest, Request, Response
 from b24api.error import RetryApiResponseError, RetryHTTPStatusError
 from b24api.settings import ApiSettings
-from b24api.transport import HttpxClient
 
 
 class Bitrix24:
+    http: Client = Client(http2=True)
+
     @inject
-    def __init__(self, client: HttpxClient, settings: ApiSettings) -> None:
-        self.client = client
+    def __init__(self, settings: ApiSettings) -> None:
         self.settings = settings
         self.logger = logging.getLogger("b24api")
 
-        retry_ = partial(
-            retry,
-            exceptions=(
-                httpx.TransportError,
-                h2.exceptions.ProtocolError,
-                RetryHTTPStatusError,
-                RetryApiResponseError,
+        self.http.timeout = self.settings.http_timeout
+
+        self.retry = Retrying(
+            retry=retry_if_exception_type(
+                (
+                    httpx.TransportError,
+                    h2.exceptions.ProtocolError,
+                    RetryHTTPStatusError,
+                    RetryApiResponseError,
+                ),
             ),
-            tries=self.settings.retry_tries,
-            delay=self.settings.retry_delay,
-            backoff=self.settings.retry_backoff,
-            logger=self.logger,
+            wait=wait_exponential(multiplier=self.settings.retry_delay, exp_base=self.settings.retry_backoff),
+            stop=stop_after_attempt(self.settings.retry_attempts),
+            before_sleep=before_sleep_log(self.logger, logging.WARNING),
+            reraise=True,
         )
-        self._call_retry = retry_()(self._call)
-        self._batch_retry = retry_()(self._batch)
 
     def call(self, request: Request | dict) -> ApiTypes:
-        """Call any method (with retries) and return just `result`."""
-        return self._call_retry(request).result
+        """Call any method (with retries) and return `result` from response."""
+        return self.retry(self._call, request).result
 
     def _call(self, request: Request | dict) -> Response:
         """Call any method and return full response."""
@@ -51,17 +52,17 @@ class Bitrix24:
 
         self.logger.debug("Sending request: %s", request)
 
-        http_response = self.client.post(
+        http_response = self.http.post(
             f"{self.settings.webhook_url}{request.method}",
             headers={"Content-Type": "application/json"},
             json=request.model_dump(mode="json")["parameters"],
         )
 
-        with contextlib.suppress(httpx.ResponseNotRead, json.JSONDecodeError, ValidationError):
-            ErrorResponse.model_validate(http_response.json()).raise_error(self.settings.retry_errors)
+        with contextlib.suppress(httpx.ResponseNotRead, ValidationError):
+            ErrorResponse.model_validate_json(http_response.content).raise_error(self.settings.retry_errors)
 
         try:
-            json_response = http_response.raise_for_status().json()
+            http_response.raise_for_status()
         except httpx.HTTPStatusError as error:
             if http_response.status_code in self.settings.retry_statuses:
                 raise RetryHTTPStatusError(
@@ -71,30 +72,36 @@ class Bitrix24:
                 ) from error
             raise
 
-        with contextlib.suppress(ValidationError):
-            ErrorResponse.model_validate(json_response).raise_error(self.settings.retry_errors)
-
-        response = Response.model_validate(json_response)
-
+        response = Response.model_validate_json(http_response.content)
         self.logger.debug("Received response: %s", response)
 
         return response
 
     def batch(
         self,
-        requests: Iterable[Request | dict],
+        requests: Iterable[Request | dict | tuple[Request | dict, Any]],
+        *,
         batch_size: int | None = None,
-    ) -> Generator[ApiTypes, None, None]:
-        """Call infinite sequence of methods within batches and return just `result`s."""
+        with_payload: bool = False,
+    ) -> Generator[ApiTypes | tuple[ApiTypes, Any]]:
+        """Call unlimited sequence of methods within batches and return `result` from responses."""
         batch_size = batch_size or self.settings.batch_size
 
         tail_requests = iter(requests)
         while batched_requests := list(islice(tail_requests, batch_size)):
-            for response in self._batch_retry(batched_requests):
-                yield response.result
+            if with_payload:
+                batched_requests, batched_payloads = zip(*batched_requests, strict=True)
+            else:
+                batched_payloads = None
+
+            for i, response in enumerate(self.retry(self._batch, batched_requests)):
+                if with_payload:
+                    yield response.result, batched_payloads[i]
+                else:
+                    yield response.result
 
     def _batch(self, requests: Iterable[Request | dict]) -> list[Response]:
-        """Call batch of methods and return full responses."""
+        """Call limited batch of methods and return full responses."""
         commands = {f"_{i}": Request.model_validate(request) for i, request in enumerate(requests)}
         request = Request(
             method="batch",
@@ -138,8 +145,9 @@ class Bitrix24:
     def list_sequential(
         self,
         request: Request | dict,
+        *,
         list_size: int | None = None,
-    ) -> Generator[ApiTypes, None, None]:
+    ) -> Generator[ApiTypes]:
         """Call `list` method and return full `result`.
 
         Slow (sequential tail) list gathering for methods without `filter` parameter (e.g. `department.get`).
@@ -150,7 +158,7 @@ class Bitrix24:
         head_request = request.model_copy(deep=True)
         head_request.parameters["start"] = 0
 
-        head_response = self._call_retry(head_request)
+        head_response = self.retry(self._call, head_request)
         yield from self._fix_list_result(head_response.result)
 
         if head_response.next and head_response.next != list_size:
@@ -160,7 +168,7 @@ class Bitrix24:
         for start in range(list_size, total, list_size):
             tail_request = head_request.model_copy(deep=True)
             tail_request.parameters["start"] = start
-            tail_response = self._call_retry(tail_request)
+            tail_response = self.retry(self._call, tail_request)
 
             if tail_response.next and tail_response.next != start + list_size:
                 raise ValueError(
@@ -171,9 +179,10 @@ class Bitrix24:
     def list_batched(
         self,
         request: Request | dict,
+        *,
         list_size: int | None = None,
         batch_size: int | None = None,
-    ) -> Generator[ApiTypes, None, None]:
+    ) -> Generator[ApiTypes]:
         """Call `list` method and return full `result`.
 
         Faster (batched tail) list gathering for methods without `filter` parameter (e.g. `department.get`).
@@ -185,20 +194,20 @@ class Bitrix24:
         head_request = request.model_copy(deep=True)
         head_request.parameters["start"] = 0
 
-        head_response = self._call_retry(head_request)
+        head_response = self.retry(self._call, head_request)
         yield from self._fix_list_result(head_response.result)
 
         if head_response.next and head_response.next != list_size:
             raise ValueError(f"Expecting chunk size to be {list_size}. Got: {head_response.next}")
 
-        def _tail_requests() -> Generator[Request, None, None]:
+        def _tail_requests() -> Generator[Request]:
             total = head_response.total or 0
             for start in range(list_size, total, list_size):
                 tail_request = head_request.model_copy(deep=True)
                 tail_request.parameters["start"] = start
                 yield tail_request
 
-        tail_responses = self.batch(_tail_requests(), batch_size)
+        tail_responses = self.batch(_tail_requests(), batch_size=batch_size)
         tail_responses = map(self._fix_list_result, tail_responses)
         tail_responses = chain.from_iterable(tail_responses)
         yield from tail_responses
@@ -206,10 +215,11 @@ class Bitrix24:
     def list_batched_no_count(
         self,
         request: ListRequest | dict,
+        *,
         id_key: str = "ID",
         list_size: int | None = None,
         batch_size: int | None = None,
-    ) -> Generator[ApiTypes, None, None]:
+    ) -> Generator[ApiTypes]:
         """Call `list` method and return full `result`.
 
         Fastest (batched, no count) list gathering for methods with `filter` parameter (e.g. `crm.lead.list`).
@@ -232,7 +242,7 @@ class Bitrix24:
             )
 
         if request.parameters.order:
-            raise ValueError("Ordering parameters are reserved `order`in `list_batched_no_count`")
+            raise ValueError("Ordering parameters are reserved in `list_batched_no_count`")
 
         head_request = request.model_copy(deep=True)
         head_request.parameters.start = -1
@@ -242,14 +252,14 @@ class Bitrix24:
         tail_request.parameters.start = -1
         tail_request.parameters.order = {"ID": "DESC"}
 
-        head_tail_result = self.batch([head_request, tail_request])
+        head_tail_result = self.batch([head_request, tail_request], batch_size=batch_size)
         head_result, tail_result = tuple(map(self._fix_list_result, head_tail_result))
         yield from head_result
 
         max_head_id = max(map(int, map(get_id, head_result)), default=None)
         min_tail_id = min(map(int, map(get_id, tail_result)), default=None)
 
-        def _body_requests() -> Generator[ListRequest, None, None]:
+        def _body_requests() -> Generator[ListRequest]:
             for start in range(max_head_id, min_tail_id, list_size):
                 body_request = head_request.model_copy(deep=True)
                 body_request.parameters.filter[id_from] = start
@@ -257,7 +267,7 @@ class Bitrix24:
                 yield body_request
 
         if max_head_id and min_tail_id and max_head_id < min_tail_id:
-            body = self.batch(_body_requests(), batch_size)
+            body = self.batch(_body_requests(), batch_size=batch_size)
             body = map(self._fix_list_result, body)
             body = chain.from_iterable(body)
             yield from body
@@ -269,12 +279,14 @@ class Bitrix24:
     def reference_batched_no_count(
         self,
         request: ListRequest | dict,
-        updates: Iterable[dict],
+        updates: Iterable[dict | tuple[dict, Any]],
+        *,
         id_key: str = "ID",
         list_size: int | None = None,
         batch_size: int | None = None,
-    ) -> Generator[ApiTypes, None, None]:
-        """Call `list` method with reference `updates` to filter and return full `result`.
+        with_payload: bool = False,
+    ) -> Generator[ApiTypes | tuple[ApiTypes, Any]]:
+        """Call `list` method with reference `updates` for `filter` and return full `result`.
 
         Fastest (batched, no count) list gathering for methods with `filter` parameter and required `reference`
         (e.g. `crm.timeline.comment.list`).
@@ -299,8 +311,13 @@ class Bitrix24:
         if request.parameters.order:
             raise ValueError("Ordering parameters are reserved `order`in `reference_batched_no_count`")
 
-        def _tail_requests() -> Generator[ListRequest, None, None]:
+        def _tail_requests() -> Generator[ListRequest | tuple[ListRequest, Any]]:
             for update in updates:
+                if with_payload:
+                    update, payload = update
+                else:
+                    payload = None
+
                 if id_from in update:
                     raise ValueError(
                         f"Filter parameters `{id_from}` is reserved in `reference_batched_no_count`",
@@ -309,21 +326,37 @@ class Bitrix24:
                 tail_request.parameters.filter |= update
                 tail_request.parameters.start = -1
                 tail_request.parameters.order = {"ID": "ASC"}
-                yield tail_request
+
+                if with_payload:
+                    yield tail_request, payload
+                else:
+                    yield tail_request
 
         head_requests = []
         tail_requests = iter(_tail_requests())
         while body_requests := head_requests + list(islice(tail_requests, batch_size - len(head_requests))):
-            body_results = self.batch(body_requests, batch_size)
+            if with_payload:
+                body_requests, body_payloads = zip(*body_requests, strict=True)
+            else:
+                body_payloads = None
+
+            body_results = self.batch(body_requests, batch_size=batch_size)
             body_results = map(self._fix_list_result, body_results)
 
             head_requests = []
-            for body_request, body_result in zip(body_requests, body_results, strict=True):
+            for i, (body_request, body_result) in enumerate(zip(body_requests, body_results, strict=True)):
                 if len(body_result) == list_size:
                     max_id = max(map(int, map(get_id, body_result)), default=None)
                     head_request = body_request.model_copy(deep=True)
                     head_request.parameters.filter[id_from] = max_id
-                    head_requests.append(head_request)
+                    if with_payload:
+                        head_requests.append((head_request, body_payloads[i]))
+                    else:
+                        head_requests.append(head_request)
+
+                if with_payload:
+                    body_payload = [body_payloads[i]] * len(body_result)
+                    body_result = zip(body_result, body_payload, strict=True)
 
                 yield from body_result
 
@@ -354,6 +387,6 @@ class Bitrix24:
         value = result[key]
 
         if not isinstance(value, list):
-            raise TypeError(f"If `result` is a `dict`, expecting single `list` item. Got: {result}")
+            raise TypeError(f"If `result` is a `dict`, expecting single item to be a `list`. Got: {result}")
 
         return value

{b24api-0.3.9 → b24api-0.4.0}/b24api/query.py

@@ -5,10 +5,7 @@ from b24api.type import ApiTypes
 
 
 def build_query(parameters: dict[int | str, ApiTypes], path: str = "%s") -> str:
-    query = []
-
-    if parameters is None:
-        return ""
+    query: list[str] = []
 
     for key, value in parameters.items():
         if value is None:

{b24api-0.3.9 → b24api-0.4.0}/b24api/settings.py

@@ -8,14 +8,10 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 
 class Settings(BaseSettings):
-    model_config = SettingsConfigDict(
-        env_prefix="bitrix24_api_",
-        env_file=".env",
-        extra="ignore",
-    )
-
     webhook_url: HttpUrl
 
+    http_timeout: int = 30
+
     retry_statuses: list[int] = (
         codes.LOCKED,
         codes.TOO_EARLY,
@@ -27,15 +23,21 @@ class Settings(BaseSettings):
     )
     retry_errors: list[str] = ["query_limit_exceeded", "operation_time_limit"]
 
-    retry_tries: int = 5
+    retry_attempts: int = 5
     retry_delay: float = 5
     retry_backoff: float = 2
 
     list_size: int = 50
     batch_size: int = 50
 
+    model_config = SettingsConfigDict(
+        env_prefix="bitrix24_api_",
+        env_file=".env",
+        extra="ignore",
+    )
+
 
-def api_settings(**kwargs: dict) -> Generator[Settings, None, None]:
+def api_settings(**kwargs: dict) -> Generator[Settings]:
     settings = Settings(**kwargs)
     yield settings
 

{b24api-0.3.9 → b24api-0.4.0/b24api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b24api
-Version: 0.3.9
+Version: 0.4.0
 Summary: Bitrix24 API
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -9,7 +9,7 @@ Requires-Dist: fast-depends>=2.4.12
 Requires-Dist: httpx[http2]>=0.28.1
 Requires-Dist: pydantic>=2.10.6
 Requires-Dist: pydantic-settings>=2.8.1
-Requires-Dist: retry>=0.9.2
+Requires-Dist: tenacity>=9.1.2
 Dynamic: license-file
 
 # API client for Bitrix24

{b24api-0.3.9 → b24api-0.4.0}/b24api.egg-info/SOURCES.txt

@@ -8,7 +8,6 @@ b24api/entity.py
 b24api/error.py
 b24api/query.py
 b24api/settings.py
-b24api/transport.py
 b24api/type.py
 b24api.egg-info/PKG-INFO
 b24api.egg-info/SOURCES.txt

{b24api-0.3.9 → b24api-0.4.0}/b24api.egg-info/requires.txt

@@ -2,4 +2,4 @@ fast-depends>=2.4.12
 httpx[http2]>=0.28.1
 pydantic>=2.10.6
 pydantic-settings>=2.8.1
-retry>=0.9.2
+tenacity>=9.1.2

{b24api-0.3.9 → b24api-0.4.0}/pyproject.toml

@@ -20,7 +20,7 @@ dependencies = [
     "httpx[http2]>=0.28.1",
     "pydantic>=2.10.6",
     "pydantic-settings>=2.8.1",
-    "retry>=0.9.2",
+    "tenacity>=9.1.2",
 ]
 
 [dependency-groups]

b24api-0.3.9/b24api/transport.py

@@ -1,14 +0,0 @@
-from collections.abc import Generator
-from typing import Annotated
-
-from fast_depends import Depends
-from httpx import Client
-
-
-def httpx_client() -> Generator[Client, None, None]:
-    client = Client(http2=True, timeout=30)
-
-    yield client
-
-
-HttpxClient = Annotated[Client, Depends(httpx_client)]