stream-chat 4.11.0__py3-none-any.whl → 4.12.1__py3-none-any.whl

stream_chat/__pkg__.py

@@ -1,6 +1,6 @@
 __author__ = "Tommaso Barbugli"
 __copyright__ = "Copyright 2019-2022, Stream.io, Inc"
-__version__ = "4.11.0"
+__version__ = "4.12.1"
 __maintainer__ = "Tommaso Barbugli"
 __email__ = "support@getstream.io"
 __status__ = "Production"

stream_chat/async_chat/campaign.py

@@ -0,0 +1,52 @@
+import datetime
+from typing import Any, Optional, Union
+
+from stream_chat.base.campaign import CampaignInterface
+from stream_chat.types.campaign import CampaignData
+from stream_chat.types.stream_response import StreamResponse
+
+
+class Campaign(CampaignInterface):
+    async def create(
+        self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
+    ) -> StreamResponse:
+        if campaign_id is not None:
+            self.campaign_id = campaign_id
+        if data is not None:
+            self.data = data
+        state = await self.client.create_campaign(  # type: ignore
+            campaign_id=self.campaign_id, data=self.data
+        )
+
+        if self.campaign_id is None and state.is_ok() and "campaign" in state:
+            self.campaign_id = state["campaign"]["id"]
+        return state
+
+    async def get(self) -> StreamResponse:
+        return await self.client.get_campaign(  # type: ignore
+            campaign_id=self.campaign_id
+        )
+
+    async def update(self, data: CampaignData) -> StreamResponse:
+        return await self.client.update_campaign(  # type: ignore
+            campaign_id=self.campaign_id, data=data
+        )
+
+    async def delete(self, **options: Any) -> StreamResponse:
+        return await self.client.delete_campaign(  # type: ignore
+            campaign_id=self.campaign_id, **options
+        )
+
+    async def start(
+        self,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
+    ) -> StreamResponse:
+        return await self.client.start_campaign(  # type: ignore
+            campaign_id=self.campaign_id, scheduled_for=scheduled_for, stop_at=stop_at
+        )
+
+    async def stop(self) -> StreamResponse:
+        return await self.client.stop_campaign(  # type: ignore
+            campaign_id=self.campaign_id
+        )

stream_chat/async_chat/client.py

@@ -13,9 +13,21 @@ from typing import (
     Optional,
     Type,
     Union,
+    cast,
 )
 from urllib.parse import urlparse
 
+from stream_chat.async_chat.campaign import Campaign
+from stream_chat.async_chat.segment import Segment
+from stream_chat.types.base import SortParam
+from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.segment import (
+    QuerySegmentsOptions,
+    QuerySegmentTargetsOptions,
+    SegmentData,
+    SegmentType,
+)
+
 if sys.version_info >= (3, 8):
     from typing import Literal
 else:
@@ -473,7 +485,7 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
             return await self._parse_response(response)
 
     async def create_blocklist(
-        self, name: str, words: Iterable[str], type: str = "regular"
+        self, name: str, words: Iterable[str], type: str = "word"
     ) -> StreamResponse:
         return await self.post(
             "blocklists", data={"name": name, "words": words, "type": type}
@@ -537,45 +549,148 @@ class StreamChatAsync(StreamChatInterface, AsyncContextManager):
     async def list_roles(self) -> StreamResponse:
         return await self.get("roles")
 
-    async def create_segment(self, segment: Dict) -> StreamResponse:
-        return await self.post("segments", data={"segment": segment})
+    def segment(  # type: ignore
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str] = None,
+        data: Optional[SegmentData] = None,
+    ) -> Segment:
+        return Segment(
+            client=self, segment_type=segment_type, segment_id=segment_id, data=data
+        )
+
+    async def create_segment(
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str] = None,
+        data: Optional[SegmentData] = None,
+    ) -> StreamResponse:
+        payload = {"type": segment_type.value}
+        if segment_id is not None:
+            payload["id"] = segment_id
+        if data is not None:
+            payload.update(cast(dict, data))
+        return await self.post("segments", data=payload)
 
-    async def query_segments(self, **params: Any) -> StreamResponse:
-        return await self.get("segments", params={"payload": json.dumps(params)})
+    async def get_segment(self, segment_id: str) -> StreamResponse:
+        return await self.get(f"segments/{segment_id}")
 
-    async def update_segment(self, segment_id: str, data: Dict) -> StreamResponse:
-        return await self.put(f"segments/{segment_id}", data={"segment": data})
+    async def query_segments(
+        self,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentsOptions] = None,
+    ) -> StreamResponse:
+        payload = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort  # type: ignore
+        if options is not None:
+            payload.update(cast(dict, options))
+        return await self.post("segments/query", data=payload)
+
+    async def update_segment(
+        self, segment_id: str, data: SegmentData
+    ) -> StreamResponse:
+        return await self.put(f"segments/{segment_id}", data=data)
 
     async def delete_segment(self, segment_id: str) -> StreamResponse:
         return await self.delete(f"segments/{segment_id}")
 
-    async def create_campaign(self, campaign: Dict) -> StreamResponse:
-        return await self.post("campaigns", data={"campaign": campaign})
+    async def segment_target_exists(
+        self, segment_id: str, target_id: str
+    ) -> StreamResponse:
+        return await self.get(f"segments/{segment_id}/target/{target_id}")
 
-    async def query_campaigns(self, **params: Any) -> StreamResponse:
-        return await self.get("campaigns", params={"payload": json.dumps(params)})
+    async def add_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> StreamResponse:
+        return await self.post(
+            f"segments/{segment_id}/addtargets", data={"target_ids": target_ids}
+        )
 
-    async def update_campaign(self, campaign_id: str, data: Dict) -> StreamResponse:
-        return await self.put(f"campaigns/{campaign_id}", data={"campaign": data})
+    async def query_segment_targets(
+        self,
+        segment_id: str,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> StreamResponse:
+        payload = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort  # type: ignore
+        if options is not None:
+            payload.update(cast(dict, options))
+        return await self.post(f"segments/{segment_id}/targets/query", data=payload)
+
+    async def remove_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> StreamResponse:
+        return await self.post(
+            f"segments/{segment_id}/deletetargets", data={"target_ids": target_ids}
+        )
 
-    async def delete_campaign(self, campaign_id: str, **options: Any) -> StreamResponse:
-        return await self.delete(f"campaigns/{campaign_id}", params=options)
+    def campaign(  # type: ignore
+        self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
+    ) -> Campaign:
+        return Campaign(client=self, campaign_id=campaign_id, data=data)
 
-    async def schedule_campaign(
-        self, campaign_id: str, scheduled_for: int = None
+    async def create_campaign(
+        self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
     ) -> StreamResponse:
-        return await self.patch(
-            f"campaigns/{campaign_id}/schedule", data={"scheduled_for": scheduled_for}
-        )
+        payload = {"id": campaign_id}
+        if data is not None:
+            payload.update(cast(dict, data))
+        return await self.post("campaigns", data=payload)
 
-    async def query_recipients(self, **params: Any) -> StreamResponse:
-        return await self.get("recipients", params={"payload": json.dumps(params)})
+    async def get_campaign(self, campaign_id: str) -> StreamResponse:
+        return await self.get(f"campaigns/{campaign_id}")
 
-    async def stop_campaign(self, campaign_id: str) -> StreamResponse:
-        return await self.patch(f"campaigns/{campaign_id}/stop")
+    async def query_campaigns(
+        self,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: QueryCampaignsOptions = None,
+    ) -> StreamResponse:
+        payload = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort  # type: ignore
+        if options is not None:
+            payload.update(cast(dict, options))
+        return await self.post("campaigns/query", data=payload)
+
+    async def update_campaign(
+        self, campaign_id: str, data: CampaignData
+    ) -> StreamResponse:
+        return await self.put(f"campaigns/{campaign_id}", data=data)
+
+    async def delete_campaign(self, campaign_id: str, **options: Any) -> StreamResponse:
+        return await self.delete(f"campaigns/{campaign_id}", options)
 
-    async def resume_campaign(self, campaign_id: str) -> StreamResponse:
-        return await self.patch(f"campaigns/{campaign_id}/resume")
+    async def start_campaign(
+        self,
+        campaign_id: str,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
+    ) -> StreamResponse:
+        payload = {}
+        if scheduled_for is not None:
+            if isinstance(scheduled_for, datetime.datetime):
+                scheduled_for = scheduled_for.isoformat()
+            payload["scheduled_for"] = scheduled_for
+        if stop_at is not None:
+            if isinstance(stop_at, datetime.datetime):
+                stop_at = stop_at.isoformat()
+            payload["stop_at"] = stop_at
+        return await self.post(f"campaigns/{campaign_id}/start", data=payload)
+
+    async def stop_campaign(self, campaign_id: str) -> StreamResponse:
+        return await self.post(f"campaigns/{campaign_id}/stop")
 
     async def test_campaign(
         self, campaign_id: str, users: Iterable[str]

stream_chat/async_chat/segment.py

@@ -0,0 +1,65 @@
+from typing import Dict, List, Optional
+
+from stream_chat.base.segment import SegmentInterface
+from stream_chat.types.base import SortParam
+from stream_chat.types.segment import QuerySegmentTargetsOptions, SegmentData
+from stream_chat.types.stream_response import StreamResponse
+
+
+class Segment(SegmentInterface):
+    async def create(
+        self, segment_id: Optional[str] = None, data: Optional[SegmentData] = None
+    ) -> StreamResponse:
+        if segment_id is not None:
+            self.segment_id = segment_id
+        if data is not None:
+            self.data = data
+
+        state = await self.client.create_segment(  # type: ignore
+            segment_type=self.segment_type, segment_id=self.segment_id, data=self.data
+        )
+
+        if self.segment_id is None and state.is_ok() and "segment" in state:
+            self.segment_id = state["segment"]["id"]
+        return state
+
+    async def get(self) -> StreamResponse:
+        return await self.client.get_segment(segment_id=self.segment_id)  # type: ignore
+
+    async def update(self, data: SegmentData) -> StreamResponse:
+        return await self.client.update_segment(  # type: ignore
+            segment_id=self.segment_id, data=data
+        )
+
+    async def delete(self) -> StreamResponse:
+        return await self.client.delete_segment(  # type: ignore
+            segment_id=self.segment_id
+        )
+
+    async def target_exists(self, target_id: str) -> StreamResponse:
+        return await self.client.segment_target_exists(  # type: ignore
+            segment_id=self.segment_id, target_id=target_id
+        )
+
+    async def add_targets(self, target_ids: list) -> StreamResponse:
+        return await self.client.add_segment_targets(  # type: ignore
+            segment_id=self.segment_id, target_ids=target_ids
+        )
+
+    async def query_targets(
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> StreamResponse:
+        return await self.client.query_segment_targets(  # type: ignore
+            segment_id=self.segment_id,
+            filter_conditions=filter_conditions,
+            sort=sort,
+            options=options,
+        )
+
+    async def remove_targets(self, target_ids: list) -> StreamResponse:
+        return await self.client.remove_segment_targets(  # type: ignore
+            segment_id=self.segment_id, target_ids=target_ids
+        )

stream_chat/base/campaign.py

@@ -0,0 +1,51 @@
+import abc
+import datetime
+from typing import Awaitable, Optional, Union
+
+from stream_chat.base.client import StreamChatInterface
+from stream_chat.types.campaign import CampaignData
+from stream_chat.types.stream_response import StreamResponse
+
+
+class CampaignInterface(abc.ABC):
+    def __init__(
+        self,
+        client: StreamChatInterface,
+        campaign_id: Optional[str] = None,
+        data: CampaignData = None,
+    ):
+        self.client = client
+        self.campaign_id = campaign_id
+        self.data = data
+
+    @abc.abstractmethod
+    def create(
+        self, campaign_id: Optional[str], data: Optional[CampaignData]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def get(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def update(
+        self, data: CampaignData
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def delete(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def start(
+        self,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def stop(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass

stream_chat/base/client.py

@@ -5,7 +5,16 @@ import hashlib
 import hmac
 import os
 import sys
-from typing import Any, Awaitable, Dict, Iterable, List, TypeVar, Union
+from typing import Any, Awaitable, Dict, Iterable, List, Optional, TypeVar, Union
+
+from stream_chat.types.base import SortParam
+from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.segment import (
+    QuerySegmentsOptions,
+    QuerySegmentTargetsOptions,
+    SegmentData,
+    SegmentType,
+)
 
 if sys.version_info >= (3, 8):
     from typing import Literal
@@ -18,6 +27,10 @@ from stream_chat.types.stream_response import StreamResponse
 
 TChannel = TypeVar("TChannel")
 
+TSegment = TypeVar("TSegment")
+
+TCampaign = TypeVar("TCampaign")
+
 
 class StreamChatInterface(abc.ABC):
     def __init__(
@@ -585,7 +598,6 @@ class StreamChatInterface(abc.ABC):
     ) -> TChannel:  # type: ignore[type-var]
         """
         Creates a channel object
-
         :param channel_type: the channel type
         :param channel_id: the id of the channel
         :param data: additional data, ie: {"members":[id1, id2, ...]}
@@ -753,7 +765,7 @@ class StreamChatInterface(abc.ABC):
 
     @abc.abstractmethod
     def create_blocklist(
-        self, name: str, words: Iterable[str], type: str = "regular"
+        self, name: str, words: Iterable[str], type: str = "word"
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Create a blocklist
@@ -918,18 +930,49 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def segment(
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str],
+        data: Optional[SegmentData],
+    ) -> TSegment:  # type: ignore[type-var]
+        """
+        Creates a channel object
+        :param segment_type: the segment type
+        :param segment_id: the id of the segment
+        :param data: the segment data, ie: {"members":[id1, id2, ...]}
+        :return: Segment
+        """
+        pass
+
     @abc.abstractmethod
     def create_segment(
-        self, segment: Dict
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str],
+        data: Optional[SegmentData] = None,
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Create a segment
         """
         pass
 
+    @abc.abstractmethod
+    def get_segment(
+        self, segment_id: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Query segments
+        """
+        pass
+
     @abc.abstractmethod
     def query_segments(
-        self, **params: Any
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentsOptions] = None,
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Query segments
@@ -938,7 +981,7 @@ class StreamChatInterface(abc.ABC):
 
     @abc.abstractmethod
     def update_segment(
-        self, segment_id: str, data: Dict
+        self, segment_id: str, data: SegmentData
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Update a segment by id
@@ -954,9 +997,70 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
+    @abc.abstractmethod
+    def segment_target_exists(
+        self, segment_id: str, target_id: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Check if a target exists in a segment
+        """
+        pass
+
+    @abc.abstractmethod
+    def add_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Add targets to a segment
+        """
+        pass
+
+    @abc.abstractmethod
+    def query_segment_targets(
+        self,
+        segment_id: str,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Query targets in a segment
+        """
+        pass
+
+    @abc.abstractmethod
+    def remove_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Delete targets from a segment
+        """
+        pass
+
+    @abc.abstractmethod
+    def campaign(
+        self, campaign_id: Optional[str], data: Optional[CampaignData]
+    ) -> TCampaign:  # type: ignore[type-var]
+        """
+        Creates a campaign object
+        :param campaign_id: the campaign id
+        :param data: campaign_id data
+        :return: Campaign
+        """
+        pass
+
     @abc.abstractmethod
     def create_campaign(
-        self, campaign: Dict
+        self, campaign_id: Optional[str], data: Optional[CampaignData]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        """
+        Create a campaign
+        """
+        pass
+
+    @abc.abstractmethod
+    def get_campaign(
+        self, campaign_id: str
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Create a campaign
@@ -965,7 +1069,10 @@ class StreamChatInterface(abc.ABC):
 
     @abc.abstractmethod
     def query_campaigns(
-        self, **params: Any
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QueryCampaignsOptions] = None,
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Query campaigns
@@ -974,7 +1081,7 @@ class StreamChatInterface(abc.ABC):
 
     @abc.abstractmethod
     def update_campaign(
-        self, campaign_id: str, data: Dict
+        self, campaign_id: str, data: CampaignData
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
         Update a campaign
@@ -991,11 +1098,14 @@ class StreamChatInterface(abc.ABC):
         pass
 
     @abc.abstractmethod
-    def schedule_campaign(
-        self, campaign_id: str, scheduled_for: int = None
+    def start_campaign(
+        self,
+        campaign_id: str,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
-        Schedule a campaign at given time
+        Start a campaign at given time or now if not specified
         """
         pass
 
@@ -1004,16 +1114,7 @@ class StreamChatInterface(abc.ABC):
         self, campaign_id: str
     ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
         """
-        Stop a in progress campaign
-        """
-        pass
-
-    @abc.abstractmethod
-    def resume_campaign(
-        self, campaign_id: str
-    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
-        """
-        Resume a stopped campaign
+        Stop an in progress campaign
         """
         pass
 
@@ -1026,15 +1127,6 @@ class StreamChatInterface(abc.ABC):
         """
         pass
 
-    @abc.abstractmethod
-    def query_recipients(
-        self, **params: Any
-    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
-        """
-        Query recipients
-        """
-        pass
-
     @abc.abstractmethod
     def revoke_tokens(
         self, since: Union[str, datetime.datetime]

stream_chat/base/segment.py

@@ -0,0 +1,72 @@
+import abc
+from typing import Awaitable, Dict, List, Optional, Union
+
+from stream_chat.base.client import StreamChatInterface
+from stream_chat.types.base import SortParam
+from stream_chat.types.segment import (
+    QuerySegmentTargetsOptions,
+    SegmentData,
+    SegmentType,
+)
+from stream_chat.types.stream_response import StreamResponse
+
+
+class SegmentInterface(abc.ABC):
+    def __init__(
+        self,
+        client: StreamChatInterface,
+        segment_type: SegmentType,
+        segment_id: Optional[str] = None,
+        data: Optional[SegmentData] = None,
+    ):
+        self.segment_type = segment_type
+        self.segment_id = segment_id
+        self.client = client
+        self.data = data
+
+    @abc.abstractmethod
+    def create(
+        self, segment_id: Optional[str] = None, data: Optional[SegmentData] = None
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def get(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def update(
+        self, data: SegmentData
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def delete(self) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def target_exists(
+        self, target_id: str
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def add_targets(
+        self, target_ids: List[str]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def query_targets(
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass
+
+    @abc.abstractmethod
+    def remove_targets(
+        self, target_ids: List[str]
+    ) -> Union[StreamResponse, Awaitable[StreamResponse]]:
+        pass

stream_chat/campaign.py

@@ -0,0 +1,60 @@
+import datetime
+from typing import Any, Optional, Union
+
+from stream_chat.base.campaign import CampaignInterface
+from stream_chat.types.campaign import CampaignData
+from stream_chat.types.stream_response import StreamResponse
+
+
+class Campaign(CampaignInterface):
+    def create(
+        self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
+    ) -> StreamResponse:
+        if campaign_id is not None:
+            self.campaign_id = campaign_id
+        if data is not None:
+            self.data = self._merge_campaign_data(self.data, data)
+        state = self.client.create_campaign(
+            campaign_id=self.campaign_id, data=self.data
+        )
+
+        if self.campaign_id is None and state.is_ok() and "campaign" in state:  # type: ignore
+            self.campaign_id = state["campaign"]["id"]  # type: ignore
+        return state  # type: ignore
+
+    def get(self) -> StreamResponse:
+        return self.client.get_campaign(campaign_id=self.campaign_id)  # type: ignore
+
+    def update(self, data: CampaignData) -> StreamResponse:
+        return self.client.update_campaign(  # type: ignore
+            campaign_id=self.campaign_id, data=data
+        )
+
+    def delete(self, **options: Any) -> StreamResponse:
+        return self.client.delete_campaign(  # type: ignore
+            campaign_id=self.campaign_id, **options
+        )
+
+    def start(
+        self,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
+    ) -> StreamResponse:
+        return self.client.start_campaign(  # type: ignore
+            campaign_id=self.campaign_id, scheduled_for=scheduled_for, stop_at=stop_at
+        )
+
+    def stop(self) -> StreamResponse:
+        return self.client.stop_campaign(campaign_id=self.campaign_id)  # type: ignore
+
+    @staticmethod
+    def _merge_campaign_data(
+        data1: Optional[CampaignData],
+        data2: Optional[CampaignData],
+    ) -> CampaignData:
+        if data1 is None:
+            return data2
+        if data2 is None:
+            return data1
+        data1.update(data2)  # type: ignore
+        return data1

stream_chat/client.py

@@ -2,16 +2,26 @@ import datetime
 import json
 import sys
 import warnings
-from typing import Any, Callable, Dict, Iterable, List, Union
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union, cast
 from urllib.parse import urlparse
 from urllib.request import Request, urlopen
 
+from stream_chat.campaign import Campaign
+from stream_chat.segment import Segment
+from stream_chat.types.base import SortParam
+from stream_chat.types.campaign import CampaignData, QueryCampaignsOptions
+from stream_chat.types.segment import (
+    QuerySegmentsOptions,
+    QuerySegmentTargetsOptions,
+    SegmentData,
+    SegmentType,
+)
+
 if sys.version_info >= (3, 8):
     from typing import Literal
 else:
     from typing_extensions import Literal
 
-
 import requests
 
 from stream_chat.__pkg__ import __version__
@@ -457,7 +467,7 @@ class StreamChat(StreamChatInterface):
         return self._parse_response(response)
 
     def create_blocklist(
-        self, name: str, words: Iterable[str], type: str = "regular"
+        self, name: str, words: Iterable[str], type: str = "word"
     ) -> StreamResponse:
         return self.post(
             "blocklists", data={"name": name, "words": words, "type": type}
@@ -518,49 +528,146 @@ class StreamChat(StreamChatInterface):
     def list_roles(self) -> StreamResponse:
         return self.get("roles")
 
-    def create_segment(self, segment: Dict) -> StreamResponse:
-        return self.post("segments", data={"segment": segment})
+    def segment(  # type: ignore
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str] = None,
+        data: Optional[SegmentData] = None,
+    ) -> Segment:
+        return Segment(
+            client=self, segment_type=segment_type, segment_id=segment_id, data=data
+        )
+
+    def create_segment(
+        self,
+        segment_type: SegmentType,
+        segment_id: Optional[str] = None,
+        data: Optional[SegmentData] = None,
+    ) -> StreamResponse:
+        payload = {"type": segment_type.value}
+        if segment_id is not None:
+            payload["id"] = segment_id
+        if data is not None:
+            payload.update(cast(dict, data))
+        return self.post("segments", data=payload)
 
-    def query_segments(self, **params: Any) -> StreamResponse:
-        return self.get("segments", params={"payload": json.dumps(params)})
+    def get_segment(self, segment_id: str) -> StreamResponse:
+        return self.get(f"segments/{segment_id}")
 
-    def update_segment(self, segment_id: str, data: Dict) -> StreamResponse:
-        return self.put(f"segments/{segment_id}", data={"segment": data})
+    def query_segments(
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentsOptions] = None,
+    ) -> StreamResponse:
+        payload = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort  # type: ignore
+        if options is not None:
+            payload.update(cast(dict, options))
+        return self.post("segments/query", data=payload)
+
+    def update_segment(self, segment_id: str, data: SegmentData) -> StreamResponse:
+        return self.put(f"segments/{segment_id}", data=data)
 
     def delete_segment(self, segment_id: str) -> StreamResponse:
         return self.delete(f"segments/{segment_id}")
 
-    def create_campaign(self, campaign: Dict) -> StreamResponse:
-        return self.post("campaigns", data={"campaign": campaign})
+    def segment_target_exists(self, segment_id: str, target_id: str) -> StreamResponse:
+        return self.get(f"segments/{segment_id}/target/{target_id}")
+
+    def add_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> StreamResponse:
+        return self.post(
+            f"segments/{segment_id}/addtargets", data={"target_ids": target_ids}
+        )
+
+    def query_segment_targets(
+        self,
+        segment_id: str,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> StreamResponse:
+        payload: Dict[str, Union[Dict[str, Any], List[SortParam]]] = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort
+        if options is not None:
+            payload.update(cast(dict, options))
+        return self.post(f"segments/{segment_id}/targets/query", data=payload)
+
+    def remove_segment_targets(
+        self, segment_id: str, target_ids: List[str]
+    ) -> StreamResponse:
+        return self.post(
+            f"segments/{segment_id}/deletetargets", data={"target_ids": target_ids}
+        )
+
+    def campaign(  # type: ignore
+        self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
+    ) -> Campaign:
+        return Campaign(client=self, campaign_id=campaign_id, data=data)
+
+    def create_campaign(
+        self, campaign_id: Optional[str] = None, data: CampaignData = None
+    ) -> StreamResponse:
+        payload = {"id": campaign_id}
+        if data is not None:
+            payload.update(cast(dict, data))
+        return self.post("campaigns", data=payload)
 
-    def query_campaigns(self, **params: Any) -> StreamResponse:
-        return self.get("campaigns", params={"payload": json.dumps(params)})
+    def get_campaign(self, campaign_id: str) -> StreamResponse:
+        return self.get(f"campaigns/{campaign_id}")
 
-    def update_campaign(self, campaign_id: str, data: Dict) -> StreamResponse:
-        return self.put(f"campaigns/{campaign_id}", data={"campaign": data})
+    def query_campaigns(
+        self,
+        filter_conditions: Optional[Dict[str, Any]] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QueryCampaignsOptions] = None,
+    ) -> StreamResponse:
+        payload = {}
+        if filter_conditions is not None:
+            payload["filter"] = filter_conditions
+        if sort is not None:
+            payload["sort"] = sort  # type: ignore
+        if options is not None:
+            payload.update(cast(dict, options))
+        return self.post("campaigns/query", data=payload)
+
+    def update_campaign(self, campaign_id: str, data: CampaignData) -> StreamResponse:
+        return self.put(f"campaigns/{campaign_id}", data=data)
 
     def delete_campaign(self, campaign_id: str, **options: Any) -> StreamResponse:
-        return self.delete(f"campaigns/{campaign_id}", params=options)
+        return self.delete(f"campaigns/{campaign_id}", options)
 
-    def schedule_campaign(
-        self, campaign_id: str, scheduled_for: int = None
+    def start_campaign(
+        self,
+        campaign_id: str,
+        scheduled_for: Optional[Union[str, datetime.datetime]] = None,
+        stop_at: Optional[Union[str, datetime.datetime]] = None,
     ) -> StreamResponse:
-        return self.patch(
-            f"campaigns/{campaign_id}/schedule", data={"scheduled_for": scheduled_for}
-        )
+        payload = {}
+        if scheduled_for is not None:
+            if isinstance(scheduled_for, datetime.datetime):
+                scheduled_for = scheduled_for.isoformat()
+            payload["scheduled_for"] = scheduled_for
+        if stop_at is not None:
+            if isinstance(stop_at, datetime.datetime):
+                stop_at = stop_at.isoformat()
+            payload["stop_at"] = stop_at
+        return self.post(f"campaigns/{campaign_id}/start", data=payload)
 
     def stop_campaign(self, campaign_id: str) -> StreamResponse:
-        return self.patch(f"campaigns/{campaign_id}/stop")
-
-    def resume_campaign(self, campaign_id: str) -> StreamResponse:
-        return self.patch(f"campaigns/{campaign_id}/resume")
+        return self.post(f"campaigns/{campaign_id}/stop")
 
     def test_campaign(self, campaign_id: str, users: Iterable[str]) -> StreamResponse:
         return self.post(f"campaigns/{campaign_id}/test", data={"users": users})
 
-    def query_recipients(self, **params: Any) -> StreamResponse:
-        return self.get("recipients", params={"payload": json.dumps(params)})
-
     def revoke_tokens(self, since: Union[str, datetime.datetime]) -> StreamResponse:
         if isinstance(since, datetime.datetime):
             since = since.isoformat()

stream_chat/segment.py

@@ -0,0 +1,63 @@
+from typing import Dict, List, Optional
+
+from stream_chat.base.segment import SegmentInterface
+from stream_chat.types.base import SortParam
+from stream_chat.types.segment import QuerySegmentTargetsOptions, SegmentData
+from stream_chat.types.stream_response import StreamResponse
+
+
+class Segment(SegmentInterface):
+    def create(
+        self, segment_id: Optional[str] = None, data: Optional[SegmentData] = None
+    ) -> StreamResponse:
+        if segment_id is not None:
+            self.segment_id = segment_id
+        if data is not None:
+            self.data = data
+
+        state = self.client.create_segment(
+            segment_type=self.segment_type, segment_id=self.segment_id, data=self.data
+        )
+
+        if self.segment_id is None and state.is_ok() and "segment" in state:  # type: ignore
+            self.segment_id = state["segment"]["id"]  # type: ignore
+        return state  # type: ignore
+
+    def get(self) -> StreamResponse:
+        return self.client.get_segment(segment_id=self.segment_id)  # type: ignore
+
+    def update(self, data: SegmentData) -> StreamResponse:
+        return self.client.update_segment(  # type: ignore
+            segment_id=self.segment_id, data=data
+        )
+
+    def delete(self) -> StreamResponse:
+        return self.client.delete_segment(segment_id=self.segment_id)  # type: ignore
+
+    def target_exists(self, target_id: str) -> StreamResponse:
+        return self.client.segment_target_exists(  # type: ignore
+            segment_id=self.segment_id, target_id=target_id
+        )
+
+    def add_targets(self, target_ids: list) -> StreamResponse:
+        return self.client.add_segment_targets(  # type: ignore
+            segment_id=self.segment_id, target_ids=target_ids
+        )
+
+    def query_targets(
+        self,
+        filter_conditions: Optional[Dict] = None,
+        sort: Optional[List[SortParam]] = None,
+        options: Optional[QuerySegmentTargetsOptions] = None,
+    ) -> StreamResponse:
+        return self.client.query_segment_targets(  # type: ignore
+            segment_id=self.segment_id,
+            sort=sort,
+            filter_conditions=filter_conditions,
+            options=options,
+        )
+
+    def remove_targets(self, target_ids: list) -> StreamResponse:
+        return self.client.remove_segment_targets(  # type: ignore
+            segment_id=self.segment_id, target_ids=target_ids
+        )

stream_chat/types/base.py

@@ -0,0 +1,45 @@
+import sys
+from enum import IntEnum
+from typing import Optional
+
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+
+class SortOrder(IntEnum):
+    """
+    Represents the sort order for a query.
+    """
+
+    ASC = 1
+    DESC = -1
+
+
+class SortParam(TypedDict, total=False):
+    """
+    Represents a sort parameter for a query.
+
+    Parameters:
+        field: The field to sort by.
+        direction: The direction to sort by.
+    """
+
+    field: str
+    direction: SortOrder
+
+
+class Pager(TypedDict, total=False):
+    """
+    Represents the data structure for a pager.
+
+    Parameters:
+        limit: The maximum number of items to return.
+        next: The next page token.
+        prev: The previous page token.
+    """
+
+    limit: Optional[int]
+    next: Optional[str]
+    prev: Optional[str]

stream_chat/types/campaign.py

@@ -0,0 +1,78 @@
+import sys
+from typing import Dict, List, Optional
+
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+from stream_chat.types.base import Pager
+
+
+class MessageTemplate(TypedDict, total=False):
+    """
+    Represents the data structure for a message template.
+
+    Parameters:
+        text: The text of the message.
+        attachments: List of the message attachments.
+        custom: Custom data.
+    """
+
+    text: str
+    attachments: Optional[List[Dict]]
+    custom: Optional[Dict]
+
+
+class ChannelTemplate(TypedDict, total=False):
+    """
+    Represents the data structure for a channel template.
+
+    Parameters:
+        type: The type of channel.
+        id: The ID of the channel.
+        members: List of member IDs.
+        custom: Custom data.
+    """
+
+    type: str
+    id: Optional[str]
+    members: Optional[List[str]]
+    custom: Optional[Dict]
+
+
+class CampaignData(TypedDict, total=False):
+    """
+    Represents the data structure for a campaign.
+
+    Either `segment_ids` or `user_ids` must be provided, but not both.
+
+    If `create_channels` is True, `channel_template` must be provided.
+
+    Parameters:
+        message_template: The template for the message to be sent in the campaign.
+        sender_id: The ID of the user who is sending the campaign.
+        segment_ids: List of segment IDs the campaign is targeting.
+        user_ids: List of individual user IDs the campaign is targeting.
+        create_channels: Flag to indicate if new channels should be created for the campaign.
+        channel_template: The template for channels to be created, if applicable.
+        name: The name of the campaign.
+        description: A description of the campaign.
+        skip_push: Flag to indicate if push notifications should be skipped.
+        skip_webhook: Flag to indicate if webhooks should be skipped.
+    """
+
+    message_template: MessageTemplate
+    sender_id: str
+    segment_ids: Optional[List[str]]
+    user_ids: Optional[List[str]]
+    create_channels: Optional[bool]
+    channel_template: Optional[ChannelTemplate]
+    name: Optional[str]
+    description: Optional[str]
+    skip_push: Optional[bool]
+    skip_webhook: Optional[bool]
+
+
+class QueryCampaignsOptions(Pager, total=False):
+    pass

stream_chat/types/segment.py

@@ -0,0 +1,46 @@
+import sys
+from enum import Enum
+from typing import Dict, Optional
+
+if sys.version_info >= (3, 8):
+    from typing import TypedDict
+else:
+    from typing_extensions import TypedDict
+
+from stream_chat.types.base import Pager
+
+
+class SegmentType(Enum):
+    """
+    Represents the type of segment.
+
+    Attributes:
+        CHANNEL: A segment targeting channels.
+        USER: A segment targeting users.
+    """
+
+    CHANNEL = "channel"
+    USER = "user"
+
+
+class SegmentData(TypedDict, total=False):
+    """
+    Represents the data structure for a segment.
+
+    Parameters:
+        name: The name of the segment.
+        description: A description of the segment.
+        filter: A filter to apply to the segment.
+    """
+
+    name: Optional[str]
+    description: Optional[str]
+    filter: Optional[Dict]
+
+
+class QuerySegmentsOptions(Pager, total=False):
+    pass
+
+
+class QuerySegmentTargetsOptions(Pager, total=False):
+    pass

stream_chat/types/stream_response.py

@@ -65,3 +65,7 @@ class StreamResponse(dict):
     def status_code(self) -> int:
         """Returns the HTTP status code of the response."""
         return self.__status_code
+
+    def is_ok(self) -> bool:
+        """Returns True if the status code is in the 200 range."""
+        return 200 <= self.__status_code < 300

{stream_chat-4.11.0.dist-info → stream_chat-4.12.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.1
 Name: stream-chat
-Version: 4.11.0
+Version: 4.12.1
 Summary: Client for Stream Chat.
 Home-page: https://github.com/GetStream/stream-chat-python
 Author: Tommaso Barbugli
 Author-email: support@getstream.io
 Project-URL: Bug Tracker, https://github.com/GetStream/stream-chat-python/issues
 Project-URL: Documentation, https://getstream.io/activity-feeds/docs/python/?language=python
-Project-URL: Release Notes, https://github.com/GetStream/stream-chat-python/releases/tag/v4.11.0
+Project-URL: Release Notes, https://github.com/GetStream/stream-chat-python/releases/tag/v4.12.1
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: System Administrators
 Classifier: Operating System :: OS Independent

stream_chat-4.12.1.dist-info/RECORD

@@ -0,0 +1,29 @@
+stream_chat/__init__.py,sha256=xYQuC8xcPLJxJnFWzaNaO-sVUc7IJZYe13OIPRaDBEA,116
+stream_chat/__pkg__.py,sha256=n_cQUeLvytzgt4sytXXqvw9Fe8FMTfvFz-1c7JdKYjk,206
+stream_chat/campaign.py,sha256=Z7bBo2rGMs02JkA1k9_206J0spcSLecjdhQuRnrc2Eo,2156
+stream_chat/channel.py,sha256=SxlnRM8U1yo_k3wDBC4azz3_LDRPclDV5GBmGCfqB8U,7766
+stream_chat/client.py,sha256=0PacvOGFy7FKIwYEex1VVkl604EWMeEJdmQ3NjpfW14,28160
+stream_chat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stream_chat/segment.py,sha256=NqfjNZ9i7RYlLkBohxu3-Xc4l3zo3fnKoh2IMLAUrmo,2387
+stream_chat/async_chat/__init__.py,sha256=V6x7yDCdXbP3vMuSan6Xm7RE_njZUvflImqOxfKRt4Y,67
+stream_chat/async_chat/campaign.py,sha256=Bc3iHZigxserUycZK4wDuXU0wXVH2G6fIDiYNVYPkeE,1885
+stream_chat/async_chat/channel.py,sha256=yn9P7u1lJdwoCVw9gKotadq6s1rdYSM_wnxhdaZpnTI,8124
+stream_chat/async_chat/client.py,sha256=KRebkAv-eMO87XYGbDWKlag3ba99KpEghjkbWmw5LrU,30314
+stream_chat/async_chat/segment.py,sha256=qo8waiGTkRRDRFYKW0GtrcSgnBkDF-PVSaCSBEnYwAg,2473
+stream_chat/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stream_chat/base/campaign.py,sha256=dAVkTYyirEpgyOPn8JyDebNMKeJu02vTuqgmPvdQoWU,1449
+stream_chat/base/channel.py,sha256=G6thUgND74z0gvI-N3b3vEsrDJ-D4MrAfW2um_E4x9w,13788
+stream_chat/base/client.py,sha256=uY0OsIqOPHs1vWtdov6o4kAoo2IdEYqMb-KBG_kewqQ,40247
+stream_chat/base/exceptions.py,sha256=eh1qW5d6zjUrlgsHNEBebAr0jVH2UupZ06w8sp2cseI,819
+stream_chat/base/segment.py,sha256=_UONbdF4OjaGIpsTzyY5UN_U3VAfuZyAkJnS3RfsM5k,2020
+stream_chat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+stream_chat/types/base.py,sha256=JKlOxQVPvMClTo0ev63Ya-K-dX-98j95qSE-KKzziEE,858
+stream_chat/types/campaign.py,sha256=JyAn08oMaEsxPSqmVTdsfJK4xpfErPQV7Xr7zLQm99M,2293
+stream_chat/types/rate_limit.py,sha256=v3Z4Ur0yoEdFLiHa1CNABEej2nxPlHQ6Bpy2XxW-TYQ,165
+stream_chat/types/segment.py,sha256=28pLB3ADJcF8Y5PZHa4VACVg-ySxM94nCiP4uNvQxfs,925
+stream_chat/types/stream_response.py,sha256=jWKPrOU7u6dZ2SyOK53uQCXTstrL1HshO9fA7R6Bt_A,2391
+stream_chat-4.12.1.dist-info/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
+stream_chat-4.12.1.dist-info/METADATA,sha256=URkKgtoi9hOx2F1cKXNLX27lb5xKPz559eGDPt4cKWY,7332
+stream_chat-4.12.1.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+stream_chat-4.12.1.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
+stream_chat-4.12.1.dist-info/RECORD,,

stream_chat-4.11.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-stream_chat/__init__.py,sha256=xYQuC8xcPLJxJnFWzaNaO-sVUc7IJZYe13OIPRaDBEA,116
-stream_chat/__pkg__.py,sha256=cKE0dhcuFNoI1Qxw7fK9cL1RP8-7ACqiQHVOJ5MyS4g,206
-stream_chat/channel.py,sha256=SxlnRM8U1yo_k3wDBC4azz3_LDRPclDV5GBmGCfqB8U,7766
-stream_chat/client.py,sha256=yIdkT1vTDKluM369jxo5F9xdbDVZBOUMOVZcFVE4Kv8,24333
-stream_chat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stream_chat/async_chat/__init__.py,sha256=V6x7yDCdXbP3vMuSan6Xm7RE_njZUvflImqOxfKRt4Y,67
-stream_chat/async_chat/channel.py,sha256=yn9P7u1lJdwoCVw9gKotadq6s1rdYSM_wnxhdaZpnTI,8124
-stream_chat/async_chat/client.py,sha256=hzxydYb2Aj5rQqMF8Im-5GFQUYr0Lyyb2CyVQDCDyFU,26405
-stream_chat/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stream_chat/base/channel.py,sha256=G6thUgND74z0gvI-N3b3vEsrDJ-D4MrAfW2um_E4x9w,13788
-stream_chat/base/client.py,sha256=FjfkHOh-BMpoejHAeNKa0q_5L1mGk6dE9aLpvxHyXac,37443
-stream_chat/base/exceptions.py,sha256=eh1qW5d6zjUrlgsHNEBebAr0jVH2UupZ06w8sp2cseI,819
-stream_chat/types/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-stream_chat/types/rate_limit.py,sha256=v3Z4Ur0yoEdFLiHa1CNABEej2nxPlHQ6Bpy2XxW-TYQ,165
-stream_chat/types/stream_response.py,sha256=UdMAORACY6UwYskDx_vNnMTmJral24ocqYvCR8TQQHs,2247
-stream_chat-4.11.0.dist-info/LICENSE,sha256=H66SBDuPWSRHzKPEdyjAk3C0THQRcGPfqqve4naQuu0,14424
-stream_chat-4.11.0.dist-info/METADATA,sha256=rZR3go2YcoU8ZUKVK6TnX960-JRv7QRhv8cv7nQbsK0,7332
-stream_chat-4.11.0.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-stream_chat-4.11.0.dist-info/top_level.txt,sha256=26uTfg4bWcEaFrVKlzGGgfONH1p5DDe21G07EKfYSvo,12
-stream_chat-4.11.0.dist-info/RECORD,,