b24api 0.1.3__tar.gz → 0.2.0__tar.gz

b24api-0.2.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.2
+Name: b24api
+Version: 0.2.0
+Summary: Bitrix24 API
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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
+
+# API client for Bitrix24
+
+Low-level API client with multiple strategies for lists gathering.
+All methods support retries.
+
+## Regular call (any method)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.call({"method": "user.access", "parameters": {"ACCESS": ["G2", "AU"]}})
+print(result)
+```
+
+## Batch call (any method, no limit)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+
+requests = ({"method": "user.update", "parameters": {"ID": u, "UF_SKYPE": ""}} for u in range(1000))
+result = b24.batch(requests)
+print(result)
+```
+
+## Gathering full list (slow)
+Applicable to list methods with `start=<offset>` support. 
+Fetches list chunks one by one.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_sequential({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (faster)
+Applicable to list methods with `start=<offset>` support. 
+Fetches first list chunk with regular call, then fetches other chunks with `batch`.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (fastest)
+Applicable to list methods with `filter={<parameters>}` support. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched_no_count({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list with required reference
+Applicable to list methods with `select=[<fields>]` and `filter={<parameters>}` support and required filter parameters. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+deal_ids = [1, 2, 3]  # deals IDs (e.g. from "crm.deal.list" call)
+filter_updates = ({"=ENTITY_ID": i} for i in deal_ids)
+result = b24.reference_batched_no_count(
+    {"method": "crm.timeline.comment.list", "parameters": {"ENTITY_TYPE": "deal"}},
+    filter_updates,
+)
+print(list(result))
+```

b24api-0.2.0/README.md

@@ -0,0 +1,77 @@
+# API client for Bitrix24
+
+Low-level API client with multiple strategies for lists gathering.
+All methods support retries.
+
+## Regular call (any method)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.call({"method": "user.access", "parameters": {"ACCESS": ["G2", "AU"]}})
+print(result)
+```
+
+## Batch call (any method, no limit)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+
+requests = ({"method": "user.update", "parameters": {"ID": u, "UF_SKYPE": ""}} for u in range(1000))
+result = b24.batch(requests)
+print(result)
+```
+
+## Gathering full list (slow)
+Applicable to list methods with `start=<offset>` support. 
+Fetches list chunks one by one.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_sequential({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (faster)
+Applicable to list methods with `start=<offset>` support. 
+Fetches first list chunk with regular call, then fetches other chunks with `batch`.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (fastest)
+Applicable to list methods with `filter={<parameters>}` support. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched_no_count({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list with required reference
+Applicable to list methods with `select=[<fields>]` and `filter={<parameters>}` support and required filter parameters. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+deal_ids = [1, 2, 3]  # deals IDs (e.g. from "crm.deal.list" call)
+filter_updates = ({"=ENTITY_ID": i} for i in deal_ids)
+result = b24.reference_batched_no_count(
+    {"method": "crm.timeline.comment.list", "parameters": {"ENTITY_TYPE": "deal"}},
+    filter_updates,
+)
+print(list(result))
+```

{b24api-0.1.3 → b24api-0.2.0}/b24api/api.py

@@ -1,17 +1,17 @@
 import contextlib
+import logging
 from collections.abc import Generator, Iterable
-from itertools import chain
+from itertools import chain, islice
 from operator import itemgetter
 
 import httpx
 from fast_depends import inject
 from pydantic import ValidationError
-from retry.api import retry_call
+from retry import retry
 
-from b24api.entity import ApiTypes, BatchResult, ErrorResponse, ListRequest, Request, ResultResponse
+from b24api.entity import ApiTypes, BatchResult, ErrorResponse, ListRequest, Request, Response
 from b24api.error import RetryApiResponseError, RetryHTTPStatusError
-from b24api.future import batched
-from b24api.http import HttpxClient
+from b24api.httpc import HttpxClient
 from b24api.settings import ApiSettings
 
 
@@ -20,22 +20,27 @@ class Bitrix24:
     def __init__(self, client: HttpxClient, settings: ApiSettings) -> None:
         self.client = client
         self.settings = settings
-
-    def call(self, request: Request) -> ApiTypes:
-        """Call any method (with retries) and return just `result`."""
-        response = retry_call(
-            self._call,
-            fargs=[request],
+        self.logger = logging.getLogger(__name__)
+        self._call_retry = retry(
             exceptions=(RetryHTTPStatusError, RetryApiResponseError),
             tries=self.settings.retry_tries,
             delay=self.settings.retry_delay,
             backoff=self.settings.retry_backoff,
-        )
+            logger=self.logger,
+        )(self._call)
+
+    def call(self, request: Request | dict) -> ApiTypes:
+        """Call any method (with retries) and return just `result`."""
+        response = self._call_retry(request)
 
         return response.result
 
-    def _call(self, request: Request) -> ResultResponse:
+    def _call(self, request: Request | dict) -> Response:
         """Call any method and return full response."""
+        request = Request.model_validate(request)
+
+        self.logger.debug("Sending request", extra={"request": request})
+
         http_response = self.client.post(
             f"{self.settings.webhook_url}{request.method}",
             headers={"Content-Type": "application/json"},
@@ -56,23 +61,37 @@ class Bitrix24:
         with contextlib.suppress(ValidationError):
             ErrorResponse.model_validate(json_response).raise_error(self.settings.retry_errors)
 
-        return ResultResponse.model_validate(json_response)
+        response = Response.model_validate(json_response)
+
+        self.logger.debug("Received response", extra={"request": request, "response": response})
+        self.logger.info(
+            "Received response",
+            extra={
+                "method": request.method,
+                "duration": response.time.duration,
+                "processing": response.time.processing,
+                "operating": response.time.operating,
+            },
+        )
+
+        return response
 
     def batch(
         self,
-        requests: Iterable[Request],
+        requests: Iterable[Request | dict],
         batch_size: int | None = None,
     ) -> Generator[ApiTypes, None, None]:
         """Call infinite sequence of methods within batches and return just `result`s."""
         batch_size = batch_size or self.settings.batch_size
 
-        for batched_requests in batched(requests, batch_size):
+        tail_requests = iter(requests)
+        while batched_requests := list(islice(tail_requests, batch_size)):
             for response in self._batch(batched_requests):
                 yield response.result
 
-    def _batch(self, requests: Iterable[Request]) -> Generator[ResultResponse, None, None]:
+    def _batch(self, requests: Iterable[Request | dict]) -> Generator[Response, None, None]:
         """Call batch of methods and return full responses."""
-        commands = {f"_{i}": request for i, request in enumerate(requests)}
+        commands = {f"_{i}": Request.model_validate(request) for i, request in enumerate(requests)}
         request = Request(
             method="batch",
             parameters={
@@ -105,7 +124,7 @@ class Bitrix24:
                     f"Expecting `result_time` to contain result for command {{`{key}`: {command}}}. Got: {result}",
                 )
 
-            yield ResultResponse(
+            yield Response(
                 result=result.result[key],
                 time=result.result_time[key],
                 total=result.result_total.get(key, None),
@@ -114,17 +133,21 @@ class Bitrix24:
 
     def list_sequential(
         self,
-        head_request: Request,
+        request: Request | dict,
         list_size: int | None = None,
     ) -> Generator[ApiTypes, None, None]:
         """Call `list` method and return full `result`.
 
         Slow (sequential tail) list gathering for methods without `filter` parameter (e.g. `department.get`).
         """
+        request = Request.model_validate(request)
         list_size = list_size or self.settings.list_size
 
-        head_response = self._call(head_request)
-        yield from self._normalize_list(head_response.result)
+        head_request = request.model_copy(deep=True)
+        head_request.parameters["start"] = 0
+
+        head_response = self._call_retry(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 list chunk size to be {list_size}. Got: {head_response.next}")
@@ -132,19 +155,18 @@ class Bitrix24:
         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}
-            tail_response = self._call(tail_request)
+            tail_request.parameters["start"] = start
+            tail_response = self._call_retry(tail_request)
 
             if tail_response.next and tail_response.next != start + list_size:
                 raise ValueError(
                     f"Expecting next list chunk to start at {start + list_size}. Got: {tail_response.next}",
                 )
-
-            yield from self._normalize_list(tail_response.result)
+            yield from self._fix_list_result(tail_response.result)
 
     def list_batched(
         self,
-        head_request: Request,
+        request: Request | dict,
         list_size: int | None = None,
         batch_size: int | None = None,
     ) -> Generator[ApiTypes, None, None]:
@@ -152,11 +174,15 @@ class Bitrix24:
 
         Faster (batched tail) list gathering for methods without `filter` parameter (e.g. `department.get`).
         """
+        request = Request.model_validate(request)
         list_size = list_size or self.settings.list_size
         batch_size = batch_size or self.settings.batch_size
 
-        head_response = self._call(head_request)
-        yield from self._normalize_list(head_response.result)
+        head_request = request.model_copy(deep=True)
+        head_request.parameters["start"] = 0
+
+        head_response = self._call_retry(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}")
@@ -165,18 +191,17 @@ class Bitrix24:
             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}
+                tail_request.parameters["start"] = start
                 yield tail_request
 
         tail_responses = self.batch(_tail_requests(), batch_size)
-        tail_responses = map(self._normalize_list, tail_responses)
+        tail_responses = map(self._fix_list_result, tail_responses)
         tail_responses = chain.from_iterable(tail_responses)
-
         yield from tail_responses
 
     def list_batched_no_count(
         self,
-        request: ListRequest,
+        request: ListRequest | dict,
         id_key: str = "ID",
         list_size: int | None = None,
         batch_size: int | None = None,
@@ -185,6 +210,7 @@ class Bitrix24:
 
         Fastest (batched, no count) list gathering for methods with `filter` parameter (e.g. `crm.lead.list`).
         """
+        request = ListRequest.model_validate(request)
         list_size = list_size or self.settings.list_size
         batch_size = batch_size or self.settings.batch_size
 
@@ -192,7 +218,8 @@ class Bitrix24:
         if "*" not in select_ and id_key not in select_:
             request.select.append(id_key)
 
-        id_from, id_to = f">={id_key}", f"<{id_key}"
+        id_from, id_to = f">{id_key}", f"<{id_key}"
+        get_id = itemgetter(id_key)
 
         filter_ = request.parameters.filter
         if filter_ and (id_from in filter_ or id_to in filter_):
@@ -211,39 +238,94 @@ class Bitrix24:
         tail_request.parameters.start = -1
         tail_request.parameters.order = {"ID": "DESC"}
 
-        head_tail = self.batch([head_request, tail_request])
-        head, tail = tuple(map(self._normalize_list, head_tail))
+        head_tail_result = self.batch([head_request, tail_request])
+        head_result, tail_result = tuple(map(self._fix_list_result, head_tail_result))
+        yield from head_result
 
-        get_id = itemgetter(id_key)
-        max_head = max(map(int, map(get_id, head)), default=None)
-        min_tail = min(map(int, map(get_id, tail)), default=None)
-
-        yield from head
-
-        if max_head < min_tail:
+        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[Request, None, None]:
-                for start in range(max_head + 1, min_tail, list_size):
-                    body_request = request.model_copy(deep=True)
-                    body_request.parameters.start = -1
-                    body_request.parameters.filter[id_from] = start
-                    body_request.parameters.filter[id_to] = min(start + list_size, min_tail)
-                    body_request.parameters.order = {"ID": "ASC"}
-                    yield body_request
+        def _body_requests() -> Generator[ListRequest, None, None]:
+            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
+                body_request.parameters.filter[id_to] = min(start + list_size + 1, min_tail_id)
+                yield body_request
 
+        if max_head_id < min_tail_id:
             body = self.batch(_body_requests(), batch_size)
-            body = map(self._normalize_list, body)
+            body = map(self._fix_list_result, body)
             body = chain.from_iterable(body)
-
             yield from body
 
-        for item in reversed(tail):
-            if int(get_id(item)) > max_head:
+        for item in reversed(tail_result):
+            if int(get_id(item)) > max_head_id:
                 yield item
 
+    def reference_batched_no_count(
+        self,
+        request: ListRequest | dict,
+        updates: Iterable[dict],
+        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`.
+
+        Fastest (batched, no count) list gathering for methods with `filter` parameter and required `reference`
+        (e.g. `crm.timeline.comment.list`).
+        """
+        request = ListRequest.model_validate(request)
+        list_size = list_size or self.settings.list_size
+        batch_size = batch_size or self.settings.batch_size
+
+        select_ = request.parameters.select
+        if "*" not in select_ and id_key not in select_:
+            request.select.append(id_key)
+
+        id_from = f">{id_key}"
+        get_id = itemgetter(id_key)
+
+        filter_ = request.parameters.filter
+        if filter_ and id_from in filter_:
+            raise ValueError(
+                f"Filter parameters `{id_from}` is reserved in `reference_batched_no_count`",
+            )
+
+        if request.parameters.order:
+            raise ValueError("Ordering parameters are reserved `order`in `reference_batched_no_count`")
+
+        def _tail_requests() -> Generator[ListRequest, None, None]:
+            for update in updates:
+                if id_from in update:
+                    raise ValueError(
+                        f"Filter parameters `{id_from}` is reserved in `reference_batched_no_count`",
+                    )
+                tail_request = request.model_copy(deep=True)
+                tail_request.parameters.filter |= update
+                tail_request.parameters.start = -1
+                tail_request.parameters.order = {"ID": "ASC"}
+                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)
+            body_results = map(self._fix_list_result, body_results)
+
+            head_requests = []
+            for body_request, body_result in 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)
+
+                yield from body_result
+
     @staticmethod
-    def _normalize_list(result: list | dict[str, list]) -> list:
-        """Normalize `list` method result to `list of items` structure.
+    def _fix_list_result(result: list | dict[str, list]) -> list:
+        """Fix `list` method result to `list of items` structure.
 
         There are two kinds of what `list` method `result` may contain:
         - a list of items (e.g. `department-get` and `disk.folder.getchildren`),

{b24api-0.1.3 → b24api-0.2.0}/b24api/entity.py

@@ -9,7 +9,7 @@ from b24api.type import ApiTypes
 
 
 class Request(BaseModel):
-    """Common request structure."""
+    """API request."""
 
     method: str
     parameters: dict[str, ApiTypes] = {}
@@ -30,17 +30,16 @@ class Request(BaseModel):
 class ListRequestParameters(BaseModel):
     """Parameters of `*.list` requests."""
 
-    select: list[str]
-    filter: dict[str, ApiTypes] | None = None
-    order: dict[str, str] | None = None
-    limit: int | None = None
+    select: list[str] = []
+    filter: dict[str, ApiTypes] = {}
+    order: dict[str, str] = {}
     start: int | None = None
 
 
 class ListRequest(Request):
-    """List request structure."""
+    """API `*.list` request."""
 
-    parameters: ListRequestParameters = None
+    parameters: ListRequestParameters
 
 
 class ErrorResponse(BaseModel):
@@ -62,7 +61,7 @@ class ErrorResponse(BaseModel):
 
 
 class ResponseTime(BaseModel):
-    """Time structure of response."""
+    """API Response `time` structure."""
 
     start: float
     finish: float
@@ -70,12 +69,12 @@ class ResponseTime(BaseModel):
     processing: float
     date_start: datetime
     date_finish: datetime
-    operating_reset_at: float
-    operating: float
+    operating_reset_at: float | None = None
+    operating: float | None = None
 
 
-class ResultResponse(BaseModel):
-    """API data response."""
+class Response(BaseModel):
+    """API response."""
 
     result: ApiTypes
     time: ResponseTime
@@ -84,6 +83,8 @@ class ResultResponse(BaseModel):
 
 
 class BatchResult(BaseModel):
+    """API response `result` structure for `batch` method."""
+
     result: dict[str, ApiTypes]
     result_time: dict[str, ResponseTime]
     result_error: dict[str, ErrorResponse]

b24api-0.1.3/b24api/http.py → b24api-0.2.0/b24api/httpc.py

@@ -1,3 +1,4 @@
+import logging
 from collections.abc import Generator
 from typing import Annotated
 
@@ -6,7 +7,11 @@ from httpx import Client
 
 
 def httpx_client() -> Generator[Client, None, None]:
-    client = Client(http2=True)
+    httpx_logger = logging.getLogger("httpx")
+    httpx_logger.setLevel(logging.WARNING)
+
+    client = Client(http2=True, timeout=30)
+
     yield client
 
 

b24api-0.2.0/b24api/query.py

@@ -0,0 +1,36 @@
+from datetime import datetime
+from urllib.parse import quote_plus
+
+from b24api.type import ApiTypes
+
+
+def build_query(parameters: dict[int | str, ApiTypes], path: str = "%s") -> str:
+    query = []
+
+    if parameters is None:
+        return ""
+
+    for key, value in parameters.items():
+        if value is None:
+            continue
+
+        value_ = value
+
+        if isinstance(value_, list | tuple):
+            value_ = dict(enumerate(value))
+
+        if isinstance(value_, dict):
+            subquery = build_query(value_, path % key + "[%s]")
+        else:
+            key_ = quote_plus(path % key)
+
+            if isinstance(value_, datetime):
+                value_ = value.astimezone().isoformat()
+            value_ = quote_plus(str(value_))
+
+            subquery = f"{key_}={value_}"
+
+        if subquery:
+            query.append(subquery)
+
+    return "&".join(query)

{b24api-0.1.3 → b24api-0.2.0}/b24api/settings.py

@@ -9,7 +9,7 @@ from pydantic_settings import BaseSettings, SettingsConfigDict
 
 class Settings(BaseSettings):
     model_config = SettingsConfigDict(
-        env_prefix="bitrix_24_api_",
+        env_prefix="bitrix24_api_",
         env_file=".env",
         extra="ignore",
     )
@@ -35,8 +35,8 @@ class Settings(BaseSettings):
     batch_size: int = 50
 
 
-def api_settings() -> Generator[Settings, None, None]:
-    settings = Settings()
+def api_settings(**kwargs: dict) -> Generator[Settings, None, None]:
+    settings = Settings(**kwargs)
     yield settings
 
 

b24api-0.2.0/b24api.egg-info/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.2
+Name: b24api
+Version: 0.2.0
+Summary: Bitrix24 API
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+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
+
+# API client for Bitrix24
+
+Low-level API client with multiple strategies for lists gathering.
+All methods support retries.
+
+## Regular call (any method)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.call({"method": "user.access", "parameters": {"ACCESS": ["G2", "AU"]}})
+print(result)
+```
+
+## Batch call (any method, no limit)
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+
+requests = ({"method": "user.update", "parameters": {"ID": u, "UF_SKYPE": ""}} for u in range(1000))
+result = b24.batch(requests)
+print(result)
+```
+
+## Gathering full list (slow)
+Applicable to list methods with `start=<offset>` support. 
+Fetches list chunks one by one.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_sequential({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (faster)
+Applicable to list methods with `start=<offset>` support. 
+Fetches first list chunk with regular call, then fetches other chunks with `batch`.
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list (fastest)
+Applicable to list methods with `filter={<parameters>}` support. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+result = b24.list_batched_no_count({"method": "user.get"})
+print(list(result))
+```
+
+## Gathering full list with required reference
+Applicable to list methods with `select=[<fields>]` and `filter={<parameters>}` support and required filter parameters. 
+Fetches first and last list chunk with batch call, then fetches other chunks with `batch`. Doesn't use counting (`start=-1`).
+
+```python
+from b24api import Bitrix24
+
+b24 = Bitrix24()
+deal_ids = [1, 2, 3]  # deals IDs (e.g. from "crm.deal.list" call)
+filter_updates = ({"=ENTITY_ID": i} for i in deal_ids)
+result = b24.reference_batched_no_count(
+    {"method": "crm.timeline.comment.list", "parameters": {"ENTITY_TYPE": "deal"}},
+    filter_updates,
+)
+print(list(result))
+```

{b24api-0.1.3 → b24api-0.2.0}/b24api.egg-info/SOURCES.txt

@@ -6,8 +6,7 @@ b24api/__init__.py
 b24api/api.py
 b24api/entity.py
 b24api/error.py
-b24api/future.py
-b24api/http.py
+b24api/httpc.py
 b24api/query.py
 b24api/settings.py
 b24api/type.py

{b24api-0.1.3 → b24api-0.2.0}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "b24api"
-version = "0.1.3"
+version = "0.2.0"
 description = "Bitrix24 API"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -59,7 +59,7 @@ addopts = ["--strict-config", "--strict-markers"]
 xfail_strict = true
 
 [tool.pytest_env]
-BITRIX_24_API_WEBHOOK_URL = "https://bitrix24.com/rest/0/test/"
+BITRIX24_API_WEBHOOK_URL = "https://bitrix24.com/rest/0/test/"
 
 
 [tool.coverage.report]

b24api-0.1.3/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.2
-Name: b24api
-Version: 0.1.3
-Summary: Bitrix24 API
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-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
-
-# API client for Bitrix24
-
-Low-level API client with multiple strategies for lists gathering. 

b24api-0.1.3/README.md

@@ -1,3 +0,0 @@
-# API client for Bitrix24
-
-Low-level API client with multiple strategies for lists gathering. 

b24api-0.1.3/b24api/future.py

@@ -1,12 +0,0 @@
-try:
-    from itertools import batched  # python 3.12+
-except ImportError:
-    from collections.abc import Generator, Iterable
-    from itertools import islice
-
-    def batched(iterable: Iterable, n: int) -> Generator[tuple, None, None]:
-        if n < 1:
-            raise ValueError("n must be at least one")
-        iterator = iter(iterable)
-        while batch := tuple(islice(iterator, n)):
-            yield batch

b24api-0.1.3/b24api/query.py

@@ -1,31 +0,0 @@
-from datetime import datetime
-from urllib.parse import quote_plus
-
-from b24api.type import ApiTypes
-
-
-def build_query(parameters: dict[int | str, ApiTypes], convention: str = "%s") -> str:
-    query = []
-
-    if parameters is None:
-        return ""
-
-    for key, value in parameters.items():
-        if value is None:
-            continue
-
-        if isinstance(value, list | tuple):
-            value = dict(enumerate(value))  # noqa: PLW2901
-
-        if isinstance(value, dict):
-            subquery = build_query(value, convention % key + "[%s]")
-        else:
-            key_ = quote_plus(convention % key)
-            value_ = value.isoformat() if isinstance(value, datetime) else value
-            # TODO: check date filtering [with .replace(microsecond=0).astimezone()]
-            value_ = quote_plus(str(value_))
-            subquery = f"{key_}={value_}"
-
-        query.append(subquery)
-
-    return "&".join(query)

b24api-0.1.3/b24api.egg-info/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.2
-Name: b24api
-Version: 0.1.3
-Summary: Bitrix24 API
-Requires-Python: >=3.11
-Description-Content-Type: text/markdown
-License-File: LICENSE
-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
-
-# API client for Bitrix24
-
-Low-level API client with multiple strategies for lists gathering.