getstream 3.4.0__tar.gz → 3.5.0__tar.gz

{getstream-3.4.0 → getstream-3.5.0}/.github/workflows/release.yml

@@ -64,13 +64,9 @@ jobs:
         if: github.event_name == 'pull_request' && steps.already_released.outputs.value != 'true'
         env:
           PR_TITLE: ${{ github.event.pull_request.title }}
-          PR_BODY: ${{ github.event.pull_request.body }}
         run: |
-          PR_BODY_FILE=$(mktemp)
-          printf '%s' "$PR_BODY" > "$PR_BODY_FILE"
           python3 scripts/release/bump_version.py \
             --title "$PR_TITLE" \
-            --body-file "$PR_BODY_FILE" \
             --output "$GITHUB_OUTPUT"
 
       - name: Determine version bump (manual)

getstream-3.5.0/CHANGELOG.md

@@ -0,0 +1,147 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+
+- Standardized error hierarchy ([CHA-2958](https://linear.app/stream/issue/CHA-2958)).
+  New exception classes importable from `getstream` (also re-exported from
+  `getstream.exceptions`):
+    - `StreamException`: abstract base for every SDK error.
+    - `StreamApiException`: any HTTP 4xx/5xx response. Carries `status_code`,
+      `code`, `message`, `exception_fields`, `unrecoverable`,
+      `raw_response_body`, `more_info`, `details`. The `unrecoverable` flag
+      from `APIError` is now surfaced (was previously dropped on most paths).
+    - `StreamRateLimitException`: subclass of `StreamApiException` raised on
+      HTTP 429. Adds `retry_after: datetime.timedelta | None`, parsed from
+      `Retry-After` per RFC 7231 (integer seconds or HTTP-date). Missing or
+      unparseable headers map to `None`; past HTTP-dates clamp to `0`.
+    - `StreamTransportException`: raised when a network-layer failure (no
+      HTTP response received) propagates out of `httpx` — connection reset,
+      timeout, TLS handshake failure, DNS failure. Carries `error_type`
+      enum (`connection_reset` / `timeout` / `dns_failure` /
+      `tls_handshake_failed` / `unknown`). The original `httpx` exception
+      is preserved as `__cause__`.
+    - `StreamTaskException`: raised by `wait_for_task` when the polled task
+      ends in `status='failed'`. Carries `task_id`, `error_type`,
+      `description`, `stack_trace`, `version`.
+- `Stream.wait_for_task(task_id, *, poll_interval=1.0, timeout=60.0)` and
+  the matching async coroutine on `AsyncStream`. Polls `get_task` until the
+  task reaches a terminal state. On `completed` returns the
+  `StreamResponse[GetTaskResponse]`; on `failed` raises
+  `StreamTaskException` populated from `ErrorResult`; on timeout raises
+  `StreamTransportException(error_type='timeout')`.
+
+- Explicit HTTP connection pool configuration ([CHA-2956](https://linear.app/stream/issue/CHA-2956/connection-pooling)).
+  Four new kwargs on `Stream(...)` and `AsyncStream(...)`:
+    - `max_conns_per_host: int`: default `5`
+    - `idle_timeout: float` (seconds): default `55.0`
+    - `connect_timeout: float` (seconds): default `10.0`
+    - `request_timeout: float` (seconds): default `30.0` (was `6.0`; see Behavior changes)
+
+  These tune the underlying `httpx.Limits` and `httpx.Timeout`. The existing `http_client=` and `transport=` kwargs continue to act as escape hatches; when `http_client` is set, none of the four new kwargs apply. Env-var fallbacks for the new kwargs: `STREAM_MAX_CONNS_PER_HOST`, `STREAM_IDLE_TIMEOUT`, `STREAM_CONNECT_TIMEOUT`, `STREAM_REQUEST_TIMEOUT`.
+- INFO log on client construction (logger `getstream`) lists the effective pool config and whether a user-supplied `http_client` is in use.
+
+- Webhook handling spec helpers (CHA-2961): `UnknownEvent` dataclass for
+  forward-compat; `gunzip_payload`, `decode_sqs_payload`, `decode_sns_payload`
+  primitives; `parse_event` (returns typed event or `UnknownEvent` for
+  unrecognized discriminators); `verify_signature` canonical alias of
+  `verify_webhook_signature`; `verify_and_parse_webhook` HTTP composite
+  (gunzip + verify + parse); `parse_sqs` and `parse_sns` queue composites
+  (no signature parameter: queue transports are authenticated by AWS IAM,
+  so the backend emits no HMAC for queue messages today). Transparent gzip
+  via magic-byte detection.
+- New instance methods on `Stream` and `AsyncStream`:
+  `verify_signature(body, signature)` and
+  `verify_and_parse_webhook(body, signature)` that drop the api_secret parameter
+  in favor of the client's stored secret. Dual API: the module-level functions
+  in `getstream.webhook` remain available for callers who want explicit
+  secret control.
+- New instance methods on `Stream` / `AsyncStream`: `parse_sqs(message_body)`,
+  `parse_sns(notification_body)` (no signature; AWS IAM).
+- `InvalidWebhookError` exception type covering both signature mismatches and
+  malformed payloads. Distinguish failure modes via the exception message or
+  `__cause__` chain.
+- Conformance fixture suite under `tests/fixtures/webhooks/` (13 happy-path
+  event directories + 8 negative cases) for SDK conformance testing across
+  language ports.
+- Regenerated from the latest chat OpenAPI spec. New endpoints: `moderation.analyze`,
+  `moderation.bulk_action_appeals`, `moderation.get_setup_session`,
+  `moderation.upsert_setup_session`; `feeds.get_or_create_follow`,
+  `feeds.get_or_create_unfollow`, `feeds.get_user_interests`; `chat.create_segment`,
+  `chat.update_segment`, `chat.add_segment_targets`; `common.cancel_import_v2_task`;
+  `video.report_client_call_event`, together with the request/response models backing them.
+- New webhook event types `moderation.image_analysis.complete` and
+  `moderation.text_analysis.complete`, with `ModerationImageAnalysisCompleteEvent`
+  and `ModerationTextAnalysisCompleteEvent` models.
+
+### Changed
+
+- HTTP request errors raised by `httpx` (the `httpx.RequestError` family —
+  `ConnectError`, `ReadTimeout`, etc.) are now wrapped at the SDK boundary
+  in `StreamTransportException` so callers handle one Stream error category
+  instead of catching `httpx.RequestError` separately. The original `httpx`
+  exception is preserved via `__cause__` (CHA-2958).
+- **Default `request_timeout` is now `30.0` seconds (was `6.0`).** Aligns stream-py with the cross-SDK contract in CHA-2956. Existing callers using `timeout=` are unaffected; `timeout` is kept as an alias for `request_timeout`. Callers relying on the 6s ceiling for fail-fast behavior should pass `request_timeout=6.0` (or `timeout=6.0`) explicitly.
+- Default HTTP transport now caps connections per host at `5` and closes idle sockets after `55.0s`. Previous default was httpx's `100` max-connections with `5.0s` keep-alive expiry.
+- No breaking changes. All existing webhook helpers (`verify_webhook_signature`,
+  `parse_webhook_event`, `get_event_type`, event type constants) are preserved.
+- `FlagResponse` now represents the full flag record (`created_at`, `updated_at`,
+  `target_message`, `target_user`, `user`, `reason`, `details`, `custom`, and related
+  fields). The moderation flag-action acknowledgement, which carries `item_id` and
+  `duration`, moved to the new `FlagItemResponse`; `moderation.flag()` now returns
+  `FlagItemResponse`. The `/api/v2/moderation/flag` wire response is unchanged, so code
+  reading `item_id`/`duration` off the parsed response is unaffected. Code referencing
+  the `FlagResponse` type for those two fields should switch to `FlagItemResponse`.
+- `ChannelInput.config_overrides` and `ChannelDataUpdate.config_overrides` are now typed
+  as `ChannelConfigOverrides` (the override-specific field set) instead of `ChannelConfig`.
+- `enabled` on `DeliveryReceiptsResponse`, `ReadReceiptsResponse`, and
+  `TypingIndicatorsResponse` is now a required `bool` (was `Optional[bool]`).
+- `LLMRule.description`, `TargetResolution.bitrate`, and `TranslationSettings.languages` /
+  `TranslationSettings.enabled` are now optional.
+
+### Deprecated
+
+- `getstream.base.StreamAPIException` (capital `API`) is now an alias for
+  `getstream.exceptions.StreamApiException` (lowercase `Api`). Importing the
+  old name emits `DeprecationWarning`; existing `isinstance` / `except` /
+  `pytest.raises` checks continue to work because the alias resolves to the
+  same class. The legacy spelling will be removed one minor cycle after this
+  release (CHA-2958 §10).
+
+### Notes
+
+- Per-call `timeout=httpx.Timeout(...)` continues to work through `.get(...)`, `.post(...)`, etc., and pre-empts the client-level `request_timeout`.
+
+## [3.0.0b1] - 2026-02-27
+
+### Breaking Changes
+
+- Type names across all products now follow the OpenAPI spec naming convention: response types are suffixed with `Response`, input types with `Request`. See [MIGRATION_v2_to_v3.md](./MIGRATION_v2_to_v3.md) for the complete rename mapping.
+- `Event` (WebSocket envelope type) renamed to `WSEvent`. Base event type renamed from `BaseEvent` to `Event` (with field `type` instead of `T`).
+- Event composition changed from monolithic `*Preset` embeds to modular `Has*` types.
+- `Pager` renamed to `PagerResponse` and migrated from offset-based to cursor-based pagination (`next`/`prev` tokens).
+- Types that were previously `dict` or `TypedDict` (e.g., `User`, `Channel`, `Message`) are now full dataclasses with typed fields.
+
+### Added
+
+- Full product coverage: Chat, Video, Moderation, and Feeds APIs are all supported in a single SDK.
+- **Feeds**: activities, feeds, feed groups, follows, comments, reactions, collections, bookmarks, membership levels, feed views, and more.
+- **Video**: calls, recordings, transcription, closed captions, SFU, call statistics, user feedback analytics, and more.
+- **Moderation**: flags, review queue, moderation rules, config, appeals, moderation logs, and more.
+- Push notification types, preferences, and templates.
+- Webhook support: `WHEvent` envelope class for receiving webhook payloads, utility functions for decoding and verifying webhook signatures, and a full set of individual typed event dataclasses for every event across all products (Chat, Video, Moderation, Feeds) usable as discriminated event types.
+- Cursor-based pagination across all list endpoints.
+
+## [2.7.1] - 2026-02-18
+
+## [2.7.0] - 2026-02-03
+
+## [2.6.0] - 2025-12-11
+
+## [2.5.22] - 2025-10-15

{getstream-3.4.0 → getstream-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: getstream
-Version: 3.4.0
+Version: 3.5.0
 Summary: GetStream Python SDK - Build scalable activity feeds, chat, and video calling applications
 Author-email: sachaarbonel <sacha.arbonel@hotmail.fr>, tbarbugli <tbarbugli@gmail.com>
 License-File: LICENSE.md

getstream-3.5.0/getstream/__init__.py

@@ -0,0 +1,9 @@
+from getstream.exceptions import (  # noqa: F401
+    StreamApiException,
+    StreamException,
+    StreamRateLimitException,
+    StreamTaskException,
+    StreamTransportException,
+)
+from getstream.stream import Stream  # noqa: F401
+from getstream.stream import AsyncStream  # noqa: F401

{getstream-3.4.0 → getstream-3.5.0}/getstream/base.py

@@ -1,13 +1,18 @@
 import json
+import logging
 import mimetypes
 import os
 import time
 import uuid
+import warnings
 import asyncio
 from typing import Any, Dict, List, Optional, Tuple, Type, cast, get_origin
 
-from getstream.models import APIError
-from getstream.rate_limit import extract_rate_limit
+from getstream.exceptions import (
+    StreamApiException,
+    build_api_exception,
+    wrap_transport_error,
+)
 from getstream.stream_response import StreamResponse
 from getstream.generic import T
 import httpx
@@ -27,6 +32,51 @@ from getstream.common.telemetry import (
 import ijson
 
 
+# ── Connection pool defaults (CHA-2956) ──────────────────────────────
+# Kept in sync with getstream.stream constants; duplicated here so BaseClient/AsyncBaseClient can be instantiated standalone (e.g. by sub-clients constructed directly without going through Stream/AsyncStream).
+DEFAULT_MAX_CONNS_PER_HOST = 5
+DEFAULT_IDLE_TIMEOUT = 55.0
+DEFAULT_CONNECT_TIMEOUT = 10.0
+
+
+logger = logging.getLogger("getstream")
+
+
+def _resolve_pool_knobs(obj):
+    """Pull the 3 pool knobs off ``obj`` if BaseStream has set them, else fall back to spec defaults. Top-level ``Stream``/``AsyncStream`` sets them on ``self`` before calling ``super().__init__()``, so a directly instantiated sub-client (or test fixture) still gets sane values.
+
+    `is None` (not truthiness) so an explicit `0` / `0.0` from the caller is preserved rather than silently swapped for a default.
+    """
+    max_conns_per_host = getattr(obj, "max_conns_per_host", None)
+    idle_timeout = getattr(obj, "idle_timeout", None)
+    connect_timeout = getattr(obj, "connect_timeout", None)
+    return (
+        DEFAULT_MAX_CONNS_PER_HOST
+        if max_conns_per_host is None
+        else max_conns_per_host,
+        DEFAULT_IDLE_TIMEOUT if idle_timeout is None else idle_timeout,
+        DEFAULT_CONNECT_TIMEOUT if connect_timeout is None else connect_timeout,
+    )
+
+
+def _log_pool_config(cfg, *, user_http_client: bool) -> None:
+    if user_http_client:
+        logger.info(
+            "getstream connection pool: user_http_client=True (5 knobs not applied)"
+        )
+    else:
+        logger.info(
+            "getstream connection pool: "
+            "max_conns_per_host=%s idle_timeout=%ss "
+            "connect_timeout=%ss request_timeout=%ss "
+            "user_http_client=False",
+            cfg.max_conns_per_host,
+            cfg.idle_timeout,
+            cfg.connect_timeout,
+            cfg.timeout,
+        )
+
+
 def _read_file_bytes(file_path: str) -> bytes:
     with open(file_path, "rb") as f:
         return f.read()
@@ -56,9 +106,7 @@ class ResponseParserMixin:
         self, response: httpx.Response, data_type: Type[T]
     ) -> StreamResponse[T]:
         if response.status_code >= 399:
-            raise StreamAPIException(
-                response=response,
-            )
+            raise build_api_exception(response)
 
         try:
             parsed_result = json.loads(response.text) if response.text else {}
@@ -72,10 +120,8 @@ class ResponseParserMixin:
             else:
                 data = cast(T, parsed_result)
 
-        except (ValueError, AttributeError):
-            raise StreamAPIException(
-                response=response,
-            )
+        except (ValueError, AttributeError) as err:
+            raise StreamApiException(response=response) from err
 
         return StreamResponse(response, data)
 
@@ -151,12 +197,17 @@ class BaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, ABC):
         timeout=None,
         user_agent=None,
     ):
+        # The 3 pool knobs (max_conns_per_host, idle_timeout, connect_timeout) are set on ``self`` by BaseStream prior to this call when used via the top-level ``Stream``/``AsyncStream`` constructors. Sub-clients constructed directly use the spec defaults via _resolve_pool_knobs.
+        max_conns_per_host, idle_timeout, connect_timeout = _resolve_pool_knobs(self)
         super().__init__(
             api_key=api_key,
             base_url=base_url,
             token=token,
             timeout=timeout,
             user_agent=user_agent,
+            max_conns_per_host=max_conns_per_host,
+            idle_timeout=idle_timeout,
+            connect_timeout=connect_timeout,
         )
         http_client = getattr(self, "_http_client", None)
         if http_client is not None:
@@ -173,23 +224,39 @@ class BaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, ABC):
             self.client = http_client
             self._owns_http_client = False
         else:
+            limits = httpx.Limits(
+                max_connections=self.max_conns_per_host,
+                max_keepalive_connections=self.max_conns_per_host,
+                keepalive_expiry=self.idle_timeout,
+            )
+            timeout_obj = httpx.Timeout(
+                connect=self.connect_timeout,
+                read=self.timeout,
+                write=self.timeout,
+                pool=self.timeout,
+            )
             transport = getattr(self, "_transport", None)
             if transport is not None:
                 self.client = httpx.Client(
                     base_url=self.base_url or "",
-                    headers=self.headers,
+                    headers={**self.headers, "Accept-Encoding": "gzip"},
                     params=self.params,
-                    timeout=httpx.Timeout(self.timeout),
+                    timeout=timeout_obj,
+                    limits=limits,
                     transport=transport,
                 )
             else:
                 self.client = httpx.Client(
                     base_url=self.base_url or "",
-                    headers=self.headers,
+                    headers={**self.headers, "Accept-Encoding": "gzip"},
                     params=self.params,
-                    timeout=httpx.Timeout(self.timeout),
+                    timeout=timeout_obj,
+                    limits=limits,
                 )
             self._owns_http_client = True
+        # The pool-config INFO line is emitted once by BaseStream after the
+        # top-level client is built, not here, to avoid one line per
+        # sub-client construction.
 
     def __enter__(self):
         return self
@@ -224,9 +291,12 @@ class BaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, ABC):
         ) as span:
             call_kwargs = dict(kwargs)
             call_kwargs.pop("path_params", None)
-            response = getattr(self.client, method.lower())(
-                url_path, params=query_params, *args, **call_kwargs
-            )
+            try:
+                response = getattr(self.client, method.lower())(
+                    url_path, params=query_params, *args, **call_kwargs
+                )
+            except httpx.RequestError as err:
+                raise wrap_transport_error(err) from err
             duration = parse_duration_from_body(response.content)
             if duration:
                 span.set_attribute("http.server.duration", duration)
@@ -376,7 +446,7 @@ class BaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, ABC):
         Close HTTPX client.
 
         If the client was provided externally via ``http_client``, this is a
-        no-op — the caller that created the client is responsible for closing
+        no-op; the caller that created the client is responsible for closing
         it.
         """
         if getattr(self, "_owns_http_client", True):
@@ -392,12 +462,17 @@ class AsyncBaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, A
         timeout=None,
         user_agent=None,
     ):
+        # The 3 pool knobs (max_conns_per_host, idle_timeout, connect_timeout) are set on ``self`` by BaseStream prior to this call when used via the top-level ``Stream``/``AsyncStream`` constructors. Sub-clients constructed directly use the spec defaults via _resolve_pool_knobs.
+        max_conns_per_host, idle_timeout, connect_timeout = _resolve_pool_knobs(self)
         super().__init__(
             api_key=api_key,
             base_url=base_url,
             token=token,
             timeout=timeout,
             user_agent=user_agent,
+            max_conns_per_host=max_conns_per_host,
+            idle_timeout=idle_timeout,
+            connect_timeout=connect_timeout,
         )
         http_client = getattr(self, "_http_client", None)
         if http_client is not None:
@@ -414,23 +489,39 @@ class AsyncBaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, A
             self.client = http_client
             self._owns_http_client = False
         else:
+            limits = httpx.Limits(
+                max_connections=self.max_conns_per_host,
+                max_keepalive_connections=self.max_conns_per_host,
+                keepalive_expiry=self.idle_timeout,
+            )
+            timeout_obj = httpx.Timeout(
+                connect=self.connect_timeout,
+                read=self.timeout,
+                write=self.timeout,
+                pool=self.timeout,
+            )
             transport = getattr(self, "_transport", None)
             if transport is not None:
                 self.client = httpx.AsyncClient(
                     base_url=self.base_url or "",
-                    headers=self.headers,
+                    headers={**self.headers, "Accept-Encoding": "gzip"},
                     params=self.params,
-                    timeout=httpx.Timeout(self.timeout),
+                    timeout=timeout_obj,
+                    limits=limits,
                     transport=transport,
                 )
             else:
                 self.client = httpx.AsyncClient(
                     base_url=self.base_url or "",
-                    headers=self.headers,
+                    headers={**self.headers, "Accept-Encoding": "gzip"},
                     params=self.params,
-                    timeout=httpx.Timeout(self.timeout),
+                    timeout=timeout_obj,
+                    limits=limits,
                 )
             self._owns_http_client = True
+        # The pool-config INFO line is emitted once by BaseStream after the
+        # top-level client is built, not here, to avoid one line per
+        # sub-client construction.
 
     async def __aenter__(self):
         return self
@@ -442,7 +533,7 @@ class AsyncBaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, A
         """Close HTTPX async client (closes pools/keep-alives).
 
         If the client was provided externally via ``http_client``, this is a
-        no-op — the caller that created the client is responsible for closing
+        no-op; the caller that created the client is responsible for closing
         it.
         """
         if getattr(self, "_owns_http_client", True):
@@ -516,9 +607,12 @@ class AsyncBaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, A
                 call_kwargs["headers"] = call_kwargs.get("headers", {})
                 call_kwargs["headers"]["Content-Type"] = "application/json"
 
-            response = await getattr(self.client, method.lower())(
-                url_path, params=query_params, *args, **call_kwargs
-            )
+            try:
+                response = await getattr(self.client, method.lower())(
+                    url_path, params=query_params, *args, **call_kwargs
+                )
+            except httpx.RequestError as err:
+                raise wrap_transport_error(err) from err
             duration = parse_duration_from_body(response.content)
             if duration:
                 span.set_attribute("http.server.duration", duration)
@@ -633,54 +727,19 @@ class AsyncBaseClient(TelemetryEndpointMixin, BaseConfig, ResponseParserMixin, A
         )
 
 
-class StreamAPIException(Exception):
-    """
-    A custom exception for handling errors from a Stream API response.
-
-    This exception is raised when an API call encounters an issue, providing
-    detailed information from the HTTP response. It attempts to parse the response
-    content into a structured API error. If the response content is not JSON or
-    lacks the expected structure, it will simply report the HTTP status code.
-
-    Attributes:
-        api_error (Optional[APIError]): An optional APIError object that is
-            populated if the response content contains structured error information.
-        rate_limit_info (RateLimitInfo): Information about the API's rate limiting
-            controls extracted from the response headers.
-        http_response (httpx.Response): The full HTTP response object from httpx.
-        status_code (int): The HTTP status code from the response.
-
-    Args:
-        response (httpx.Response): The HTTP response received from the Stream API.
-
-    Raises:
-        ValueError: If the response content cannot be parsed into JSON, indicating
-            that the server's response was not in the expected format.
-    """
-
-    def __init__(self, response: httpx.Response) -> None:
-        self.api_error: Optional[APIError] = None
-        self.rate_limit_info = extract_rate_limit(response)
-        self.http_response = response
-        self.status_code = response.status_code
-
-        try:
-            parsed_response: Dict = json.loads(response.content)
-            self.api_error = APIError.from_dict(parsed_response)
-        except ValueError:
-            pass
-
-    def __str__(self) -> str:
-        if self.api_error:
-            return f'Stream error code {self.api_error.code}: {self.api_error.message}"'
-        body_preview = ""
-        try:
-            text = self.http_response.text[:200] if self.http_response.text else ""
-            if text:
-                body_preview = f" body: {text}"
-        except Exception:
-            pass
-        return f"Stream error HTTP code: {self.status_code}{body_preview}"
+def __getattr__(name: str):
+    """StreamApiException is exported under its new name; resolve here lazily and warn once."""
+    if name == "StreamAPIException":
+        warnings.warn(
+            "getstream.base.StreamAPIException is deprecated; import "
+            "StreamApiException from getstream (or getstream.exceptions) "
+            "instead. The legacy alias will be removed one minor cycle after "
+            "this release.",
+            DeprecationWarning,
+            stacklevel=2,
+        )
+        return StreamApiException
+    raise AttributeError(f"module 'getstream.base' has no attribute {name!r}")
 
 
 def parse_duration_from_body(body: bytes) -> Optional[str]:

{getstream-3.4.0 → getstream-3.5.0}/getstream/chat/async_rest_client.py

@@ -282,10 +282,11 @@ class ChatRestClient(AsyncBaseClient):
         self,
         limit: Optional[int] = None,
         user_id: Optional[str] = None,
+        groups: Optional[Dict[str, GroupedChannelsGroupRequest]] = None,
         user: Optional[UserRequest] = None,
     ) -> StreamResponse[GroupedQueryChannelsResponse]:
         json = GroupedQueryChannelsRequest(
-            limit=limit, user_id=user_id, user=user
+            limit=limit, user_id=user_id, groups=groups, user=user
         ).to_dict()
         return await self.post(
             "/api/v2/chat/channels/grouped", GroupedQueryChannelsResponse, json=json
@@ -1657,6 +1658,30 @@ class ChatRestClient(AsyncBaseClient):
             "/api/v2/chat/search", SearchResponse, query_params=query_params
         )
 
+    @telemetry.operation_name("getstream.api.chat.create_segment")
+    async def create_segment(
+        self,
+        type: str,
+        all_sender_channels: Optional[bool] = None,
+        all_users: Optional[bool] = None,
+        description: Optional[str] = None,
+        id: Optional[str] = None,
+        name: Optional[str] = None,
+        filter: Optional[Dict[str, object]] = None,
+    ) -> StreamResponse[CreateSegmentResponse]:
+        json = CreateSegmentRequest(
+            type=type,
+            all_sender_channels=all_sender_channels,
+            all_users=all_users,
+            description=description,
+            id=id,
+            name=name,
+            filter=filter,
+        ).to_dict()
+        return await self.post(
+            "/api/v2/chat/segments", CreateSegmentResponse, json=json
+        )
+
     @telemetry.operation_name("getstream.api.chat.query_segments")
     async def query_segments(
         self,
@@ -1691,6 +1716,42 @@ class ChatRestClient(AsyncBaseClient):
             "/api/v2/chat/segments/{id}", GetSegmentResponse, path_params=path_params
         )
 
+    @telemetry.operation_name("getstream.api.chat.update_segment")
+    async def update_segment(
+        self,
+        id: str,
+        description: Optional[str] = None,
+        name: Optional[str] = None,
+        filter: Optional[Dict[str, object]] = None,
+    ) -> StreamResponse[UpdateSegmentResponse]:
+        path_params = {
+            "id": id,
+        }
+        json = UpdateSegmentRequest(
+            description=description, name=name, filter=filter
+        ).to_dict()
+        return await self.put(
+            "/api/v2/chat/segments/{id}",
+            UpdateSegmentResponse,
+            path_params=path_params,
+            json=json,
+        )
+
+    @telemetry.operation_name("getstream.api.chat.add_segment_targets")
+    async def add_segment_targets(
+        self, id: str, target_ids: List[str]
+    ) -> StreamResponse[Response]:
+        path_params = {
+            "id": id,
+        }
+        json = AddSegmentTargetsRequest(target_ids=target_ids).to_dict()
+        return await self.post(
+            "/api/v2/chat/segments/{id}/addtargets",
+            Response,
+            path_params=path_params,
+            json=json,
+        )
+
     @telemetry.operation_name("getstream.api.chat.delete_segment_targets")
     async def delete_segment_targets(
         self, id: str, target_ids: List[str]