stream-chat 4.11.0__tar.gz → 4.12.1__tar.gz

{stream-chat-4.11.0/stream_chat.egg-info → stream-chat-4.12.1}/PKG-INFO

@@ -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.11.0 → stream-chat-4.12.1}/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-4.12.1/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-4.11.0 → stream-chat-4.12.1}/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-4.12.1/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-4.12.1/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-4.11.0 → stream-chat-4.12.1}/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]