b24api 0.3.10__tar.gz → 0.4.1__tar.gz

{b24api-0.3.10/b24api.egg-info → b24api-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b24api
-Version: 0.3.10
+Version: 0.4.1
 Summary: Bitrix24 API
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown

{b24api-0.3.10 → b24api-0.4.1}/b24api/api.py

@@ -3,6 +3,7 @@ import logging
 from collections.abc import Generator, Iterable
 from itertools import chain, islice
 from operator import itemgetter
+from typing import Any
 
 import h2.exceptions
 import httpx
@@ -58,7 +59,7 @@ class Bitrix24:
         )
 
         with contextlib.suppress(httpx.ResponseNotRead, ValidationError):
-            ErrorResponse.model_validate_json(http_response.content).raise_error(self.settings.retry_errors)
+            ErrorResponse.model_validate_json(http_response.content).raise_error(request, self.settings.retry_errors)
 
         try:
             http_response.raise_for_status()
@@ -78,16 +79,26 @@ class Bitrix24:
 
     def batch(
         self,
-        requests: Iterable[Request | dict],
+        requests: Iterable[Request | dict | tuple[Request | dict, Any]],
+        *,
         batch_size: int | None = None,
-    ) -> Generator[ApiTypes]:
+        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.retry(self._batch, 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 limited batch of methods and return full responses."""
@@ -108,7 +119,10 @@ class Bitrix24:
             key = f"_{i}"
 
             if key in result.result_error:
-                ErrorResponse.model_validate(result.result_error[key]).raise_error(self.settings.retry_errors)
+                ErrorResponse.model_validate(result.result_error[key]).raise_error(
+                    commands[key],
+                    self.settings.retry_errors,
+                )
 
             command = commands[key]
             if key not in result.result:
@@ -134,6 +148,7 @@ class Bitrix24:
     def list_sequential(
         self,
         request: Request | dict,
+        *,
         list_size: int | None = None,
     ) -> Generator[ApiTypes]:
         """Call `list` method and return full `result`.
@@ -167,6 +182,7 @@ class Bitrix24:
     def list_batched(
         self,
         request: Request | dict,
+        *,
         list_size: int | None = None,
         batch_size: int | None = None,
     ) -> Generator[ApiTypes]:
@@ -194,7 +210,7 @@ class Bitrix24:
                 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
@@ -202,6 +218,7 @@ 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,
@@ -238,7 +255,7 @@ 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
 
@@ -253,7 +270,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
@@ -265,11 +282,13 @@ 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]:
+        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`
@@ -295,8 +314,13 @@ class Bitrix24:
         if request.parameters.order:
             raise ValueError("Ordering parameters are reserved `order`in `reference_batched_no_count`")
 
-        def _tail_requests() -> Generator[ListRequest]:
+        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`",
@@ -305,21 +329,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
 

{b24api-0.3.10 → b24api-0.4.1}/b24api/entity.py

@@ -57,15 +57,17 @@ class ErrorResponse(BaseModel):
             value = value.lower()
         return value
 
-    def raise_error(self, retry_errors: list[str]) -> None:
+    def raise_error(self, request: Request, retry_errors: list[str]) -> None:
         if self.error in retry_errors:
             raise RetryApiResponseError(
                 code=self.error,
                 description=self.error_description,
+                request=str(request),
             )
         raise ApiResponseError(
             code=self.error,
             description=self.error_description,
+            request=str(request),
         )
 
 

{b24api-0.3.10 → b24api-0.4.1}/b24api/error.py

@@ -8,18 +8,13 @@ class RetryHTTPStatusError(httpx.HTTPStatusError):
 class ApiResponseError(Exception):
     """API error with description."""
 
-    def __init__(
-        self,
-        *,
-        code: str,
-        description: str | None,
-    ) -> None:
+    def __init__(self, *, code: str, description: str | None, request: str) -> None:
         if code and description:
-            message = f"API error [{code}]: {description}"
+            message = f"API error [{code}]: {description} for request {request}"
         elif code:
-            message = f"API error [{code}]"
+            message = f"API error [{code}] for request {request}"
         else:
-            message = f"API error: {description}"
+            message = f"API error: {description} for request {request}"
         super().__init__(message)
 
 

{b24api-0.3.10 → b24api-0.4.1/b24api.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: b24api
-Version: 0.3.10
+Version: 0.4.1
 Summary: Bitrix24 API
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown