index
int64 0
731k
| package
stringlengths 2
98
⌀ | name
stringlengths 1
76
| docstring
stringlengths 0
281k
⌀ | code
stringlengths 4
1.07M
⌀ | signature
stringlengths 2
42.8k
⌀ |
|---|---|---|---|---|---|
727,542 | stream_chat.client | delete_push_provider | null | def delete_push_provider(self, provider_type: str, name: str) -> StreamResponse:
return self.delete(f"push_providers/{provider_type}/{name}")
| (self, provider_type: str, name: str) -> stream_chat.types.stream_response.StreamResponse |
727,543 | stream_chat.client | delete_role | null | def delete_role(self, name: str) -> StreamResponse:
return self.delete(f"roles/{name}")
| (self, name: str) -> stream_chat.types.stream_response.StreamResponse |
727,544 | stream_chat.client | delete_segment | null | def delete_segment(self, segment_id: str) -> StreamResponse:
return self.delete(f"segments/{segment_id}")
| (self, segment_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,545 | stream_chat.client | delete_user | null | def delete_user(self, user_id: str, **options: Any) -> StreamResponse:
return self.delete(f"users/{user_id}", options)
| (self, user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,546 | stream_chat.client | delete_users | null | def delete_users(
self, user_ids: Iterable[str], delete_type: str, **options: Any
) -> StreamResponse:
return self.post(
"users/delete", data=dict(options, user=delete_type, user_ids=user_ids)
)
| (self, user_ids: Iterable[str], delete_type: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,547 | stream_chat.client | export_channel | null | def export_channel(
self,
channel_type: str,
channel_id: str,
messages_since: Union[str, datetime.datetime] = None,
messages_until: Union[str, datetime.datetime] = None,
**options: Any,
) -> StreamResponse:
if isinstance(messages_since, datetime.datetime):
messages_since = messages_since.isoformat()
if isinstance(messages_until, datetime.datetime):
messages_until = messages_until.isoformat()
return self.export_channels(
[
{
"id": channel_id,
"type": channel_type,
"messages_since": messages_since,
"messages_until": messages_until,
}
],
**options,
)
| (self, channel_type: str, channel_id: str, messages_since: Union[str, datetime.datetime, NoneType] = None, messages_until: Union[str, datetime.datetime, NoneType] = None, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,548 | stream_chat.client | export_channels | null | def export_channels(
self, channels: Iterable[Dict], **options: Any
) -> StreamResponse:
return self.post("export_channels", data={"channels": channels, **options})
| (self, channels: Iterable[Dict], **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,549 | stream_chat.client | export_user | null | def export_user(self, user_id: str, **options: Any) -> StreamResponse:
return self.get(f"users/{user_id}/export", options)
| (self, user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,550 | stream_chat.client | flag_message | null | def flag_message(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_message_id": target_id, **options}
return self.post("moderation/flag", data=data)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,551 | stream_chat.client | flag_user | null | def flag_user(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_user_id": target_id, **options}
return self.post("moderation/flag", data=data)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,552 | stream_chat.client | get | null | def get(self, relative_url: str, params: Dict = None) -> StreamResponse:
return self._make_request(self.session.get, relative_url, params, None)
| (self, relative_url: str, params: Optional[Dict] = None) -> stream_chat.types.stream_response.StreamResponse |
727,553 | stream_chat.client | get_app_settings | null | def get_app_settings(self) -> StreamResponse:
return self.get("app")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,554 | stream_chat.client | get_blocklist | null | def get_blocklist(self, name: str) -> StreamResponse:
return self.get(f"blocklists/{name}")
| (self, name: str) -> stream_chat.types.stream_response.StreamResponse |
727,555 | stream_chat.client | get_campaign | null | def get_campaign(self, campaign_id: str) -> StreamResponse:
return self.get(f"campaigns/{campaign_id}")
| (self, campaign_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,556 | stream_chat.client | get_channel_type | null | def get_channel_type(self, channel_type: str) -> StreamResponse:
return self.get(f"channeltypes/{channel_type}")
| (self, channel_type: str) -> stream_chat.types.stream_response.StreamResponse |
727,557 | stream_chat.client | get_command | null | def get_command(self, name: str) -> StreamResponse:
return self.get(f"commands/{name}")
| (self, name: str) -> stream_chat.types.stream_response.StreamResponse |
727,558 | stream_chat.base.client | get_default_params | null | def get_default_params(self) -> Dict[str, str]:
return {"api_key": self.api_key}
| (self) -> Dict[str, str] |
727,559 | stream_chat.client | get_devices | null | def get_devices(self, user_id: str) -> StreamResponse:
return self.get("devices", {"user_id": user_id})
| (self, user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,560 | stream_chat.client | get_export_channel_status | null | def get_export_channel_status(self, task_id: str) -> StreamResponse:
return self.get(f"export_channels/{task_id}")
| (self, task_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,561 | stream_chat.client | get_import | null | def get_import(self, id: str) -> StreamResponse:
return self.get(f"imports/{id}")
| (self, id: str) -> stream_chat.types.stream_response.StreamResponse |
727,562 | stream_chat.client | get_message | null | def get_message(self, message_id: str, **options: Any) -> StreamResponse:
return self.get(f"messages/{message_id}", options)
| (self, message_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,563 | stream_chat.client | get_permission | null | def get_permission(self, id: str) -> StreamResponse:
return self.get(f"permissions/{id}")
| (self, id: str) -> stream_chat.types.stream_response.StreamResponse |
727,564 | stream_chat.client | get_rate_limits | null | def get_rate_limits(
self,
server_side: bool = False,
android: bool = False,
ios: bool = False,
web: bool = False,
endpoints: Iterable[str] = None,
) -> StreamResponse:
params: Dict[str, Any] = {}
if server_side:
params["server_side"] = "true"
if android:
params["android"] = "true"
if ios:
params["ios"] = "true"
if web:
params["web"] = "true"
if endpoints:
params["endpoints"] = ",".join(endpoints)
return self.get("rate_limits", params)
| (self, server_side: bool = False, android: bool = False, ios: bool = False, web: bool = False, endpoints: Optional[Iterable[str]] = None) -> stream_chat.types.stream_response.StreamResponse |
727,565 | stream_chat.client | get_segment | null | def get_segment(self, segment_id: str) -> StreamResponse:
return self.get(f"segments/{segment_id}")
| (self, segment_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,566 | stream_chat.client | get_task | null | def get_task(self, task_id: str) -> StreamResponse:
return self.get(f"tasks/{task_id}")
| (self, task_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,567 | stream_chat.client | list_blocklists | null | def list_blocklists(self) -> StreamResponse:
return self.get("blocklists")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,568 | stream_chat.client | list_channel_types | null | def list_channel_types(self) -> StreamResponse:
return self.get("channeltypes")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,569 | stream_chat.client | list_commands | null | def list_commands(self) -> StreamResponse:
return self.get("commands")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,570 | stream_chat.client | list_imports | null | def list_imports(self, options: Dict = None) -> StreamResponse:
return self.get("imports", params=options)
| (self, options: Optional[Dict] = None) -> stream_chat.types.stream_response.StreamResponse |
727,571 | stream_chat.client | list_permissions | null | def list_permissions(self) -> StreamResponse:
return self.get("permissions")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,572 | stream_chat.client | list_push_providers | null | def list_push_providers(self) -> StreamResponse:
return self.get("push_providers")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,573 | stream_chat.client | list_roles | null | def list_roles(self) -> StreamResponse:
return self.get("roles")
| (self) -> stream_chat.types.stream_response.StreamResponse |
727,574 | stream_chat.client | mark_all_read | null | def mark_all_read(self, user_id: str) -> StreamResponse:
return self.post("channels/read", data={"user": {"id": user_id}})
| (self, user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,575 | stream_chat.client | mute_user | null | def mute_user(self, target_id: str, user_id: str, **options: Any) -> StreamResponse:
data = {"target_id": target_id, "user_id": user_id, **options}
return self.post("moderation/mute", data=data)
| (self, target_id: str, user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,576 | stream_chat.client | mute_users | null | def mute_users(
self, target_ids: List[str], user_id: str, **options: Any
) -> StreamResponse:
data = {"target_ids": target_ids, "user_id": user_id, **options}
return self.post("moderation/mute", data=data)
| (self, target_ids: List[str], user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,577 | stream_chat.base.client | normalize_sort | null | def normalize_sort(self, sort: Union[Dict, List[Dict]] = None) -> List[Dict]:
sort_fields = []
if isinstance(sort, collections.abc.Mapping):
sort = [sort] # type: ignore
if isinstance(sort, list):
for item in sort:
if "field" in item and "direction" in item:
sort_fields.append(item)
else:
for k, v in item.items():
sort_fields.append({"field": k, "direction": v})
return sort_fields
| (self, sort: Union[Dict, List[Dict], NoneType] = None) -> List[Dict] |
727,578 | stream_chat.client | patch | null | def patch(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return self._make_request(self.session.patch, relative_url, params, data)
| (self, relative_url: str, params: Optional[Dict] = None, data: Optional[Any] = None) -> stream_chat.types.stream_response.StreamResponse |
727,579 | stream_chat.client | pin_message | null | def pin_message(
self, message_id: str, user_id: str, expiration: int = None
) -> StreamResponse:
updates = {
"set": {
"pinned": True,
"pin_expires": expiration,
}
}
return self.update_message_partial(message_id, updates, user_id)
| (self, message_id: str, user_id: str, expiration: Optional[int] = None) -> stream_chat.types.stream_response.StreamResponse |
727,580 | stream_chat.client | post | null | def post(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return self._make_request(self.session.post, relative_url, params, data)
| (self, relative_url: str, params: Optional[Dict] = None, data: Optional[Any] = None) -> stream_chat.types.stream_response.StreamResponse |
727,581 | stream_chat.client | put | null | def put(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return self._make_request(self.session.put, relative_url, params, data)
| (self, relative_url: str, params: Optional[Dict] = None, data: Optional[Any] = None) -> stream_chat.types.stream_response.StreamResponse |
727,582 | stream_chat.client | query_banned_users | null | def query_banned_users(self, query_conditions: Dict) -> StreamResponse:
return self.get(
"query_banned_users", params={"payload": json.dumps(query_conditions)}
)
| (self, query_conditions: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,583 | stream_chat.client | query_campaigns | null | 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)
| (self, filter_conditions: Optional[Dict[str, Any]] = None, sort: Optional[List[stream_chat.types.base.SortParam]] = None, options: Optional[stream_chat.types.campaign.QueryCampaignsOptions] = None) -> stream_chat.types.stream_response.StreamResponse |
727,584 | stream_chat.client | query_channels | null | def query_channels(
self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
) -> StreamResponse:
params: Dict[str, Any] = {"state": True, "watch": False, "presence": False}
params.update(options)
params.update(
{"filter_conditions": filter_conditions, "sort": self.normalize_sort(sort)}
)
return self.post("channels", data=params)
| (self, filter_conditions: Dict, sort: Optional[List[Dict]] = None, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,585 | stream_chat.client | query_message_flags | null | def query_message_flags(
self, filter_conditions: Dict, **options: Any
) -> StreamResponse:
params = {
**options,
"filter_conditions": filter_conditions,
}
return self.get(
"moderation/flags/message", params={"payload": json.dumps(params)}
)
| (self, filter_conditions: Dict, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,586 | stream_chat.client | query_segment_targets | null | 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)
| (self, segment_id: str, filter_conditions: Optional[Dict[str, Any]] = None, sort: Optional[List[stream_chat.types.base.SortParam]] = None, options: Optional[stream_chat.types.segment.QuerySegmentTargetsOptions] = None) -> stream_chat.types.stream_response.StreamResponse |
727,587 | stream_chat.client | query_segments | null | 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)
| (self, filter_conditions: Optional[Dict] = None, sort: Optional[List[stream_chat.types.base.SortParam]] = None, options: Optional[stream_chat.types.segment.QuerySegmentsOptions] = None) -> stream_chat.types.stream_response.StreamResponse |
727,588 | stream_chat.client | query_users | null | def query_users(
self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
) -> StreamResponse:
params: Dict = options.copy()
params.update(
{"filter_conditions": filter_conditions, "sort": self.normalize_sort(sort)}
)
return self.get("users", params={"payload": json.dumps(params)})
| (self, filter_conditions: Dict, sort: Optional[List[Dict]] = None, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,589 | stream_chat.client | reactivate_user | null | def reactivate_user(self, user_id: str, **options: Any) -> StreamResponse:
return self.post(f"users/{user_id}/reactivate", data=options)
| (self, user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,590 | stream_chat.client | remove_segment_targets | null | 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}
)
| (self, segment_id: str, target_ids: List[str]) -> stream_chat.types.stream_response.StreamResponse |
727,591 | stream_chat.client | remove_shadow_ban | null | def remove_shadow_ban(self, target_id: str, **options: Any) -> StreamResponse:
return self.unban_user(target_id, shadow=True, **options)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,592 | stream_chat.client | restore_users | null | def restore_users(self, user_ids: Iterable[str]) -> StreamResponse:
return self.post("users/restore", data={"user_ids": user_ids})
| (self, user_ids: Iterable[str]) -> stream_chat.types.stream_response.StreamResponse |
727,593 | stream_chat.client | revoke_tokens | null | def revoke_tokens(self, since: Union[str, datetime.datetime]) -> StreamResponse:
if isinstance(since, datetime.datetime):
since = since.isoformat()
return self.update_app_settings(revoke_tokens_issued_before=since)
| (self, since: Union[str, datetime.datetime]) -> stream_chat.types.stream_response.StreamResponse |
727,594 | stream_chat.client | revoke_user_token | null | def revoke_user_token(
self, user_id: str, before: Union[str, datetime.datetime]
) -> StreamResponse:
return self.revoke_users_token([user_id], before)
| (self, user_id: str, before: Union[str, datetime.datetime]) -> stream_chat.types.stream_response.StreamResponse |
727,595 | stream_chat.client | revoke_users_token | null | def revoke_users_token(
self, user_ids: Iterable[str], before: Union[str, datetime.datetime]
) -> StreamResponse:
if isinstance(before, datetime.datetime):
before = before.isoformat()
updates = []
for user_id in user_ids:
updates.append(
{"id": user_id, "set": {"revoke_tokens_issued_before": before}}
)
return self.update_users_partial(updates)
| (self, user_ids: Iterable[str], before: Union[str, datetime.datetime]) -> stream_chat.types.stream_response.StreamResponse |
727,596 | stream_chat.client | run_message_action | null | def run_message_action(self, message_id: str, data: Dict) -> StreamResponse:
return self.post(f"messages/{message_id}/action", data=data)
| (self, message_id: str, data: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,597 | stream_chat.client | search | null | def search(
self,
filter_conditions: Dict,
query: Union[str, Dict],
sort: List[Dict] = None,
**options: Any,
) -> StreamResponse:
if "offset" in options:
if sort or "next" in options:
raise ValueError("cannot use offset with sort or next parameters")
params = self.create_search_params(filter_conditions, query, sort, **options)
return self.get("search", params={"payload": json.dumps(params)})
| (self, filter_conditions: Dict, query: Union[str, Dict], sort: Optional[List[Dict]] = None, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,598 | stream_chat.client | segment | null | 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
)
| (self, segment_type: stream_chat.types.segment.SegmentType, segment_id: Optional[str] = None, data: Optional[stream_chat.types.segment.SegmentData] = None) -> stream_chat.segment.Segment |
727,599 | stream_chat.client | segment_target_exists | null | def segment_target_exists(self, segment_id: str, target_id: str) -> StreamResponse:
return self.get(f"segments/{segment_id}/target/{target_id}")
| (self, segment_id: str, target_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,600 | stream_chat.client | send_file | null | def send_file(
self, uri: str, url: str, name: str, user: Dict, content_type: str = None
) -> StreamResponse:
headers = {
"Authorization": self.auth_token,
"stream-auth-type": "jwt",
"X-Stream-Client": get_user_agent(),
}
parts = urlparse(url)
if parts[0] == "":
with open(url, "rb") as f:
content = f.read()
else:
content = urlopen(
Request(url, headers={"User-Agent": "Mozilla/5.0"})
).read()
response = requests.post(
f"{self.base_url}/{uri}",
params=self.get_default_params(),
data={"user": json.dumps(user)},
files={"file": (name, content, content_type)}, # type: ignore
headers=headers,
)
return self._parse_response(response)
| (self, uri: str, url: str, name: str, user: Dict, content_type: Optional[str] = None) -> stream_chat.types.stream_response.StreamResponse |
727,601 | stream_chat.client | send_user_custom_event | null | def send_user_custom_event(self, user_id: str, event: Dict) -> StreamResponse:
return self.post(f"users/{user_id}/event", data={"event": event})
| (self, user_id: str, event: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,602 | stream_chat.client | set_guest_user | null | def set_guest_user(self, guest_user: Dict) -> StreamResponse:
return self.post("guest", data=dict(user=guest_user))
| (self, guest_user: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,603 | stream_chat.client | set_http_session |
You can use your own `requests.Session` instance. This instance
will be used for underlying HTTP requests.
| def set_http_session(self, session: requests.Session) -> None:
"""
You can use your own `requests.Session` instance. This instance
will be used for underlying HTTP requests.
"""
self.session = session
| (self, session: requests.sessions.Session) -> NoneType |
727,604 | stream_chat.client | shadow_ban | null | def shadow_ban(self, target_id: str, **options: Any) -> StreamResponse:
return self.ban_user(target_id, shadow=True, **options)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,605 | stream_chat.client | start_campaign | null | 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 self.post(f"campaigns/{campaign_id}/start", data=payload)
| (self, campaign_id: str, scheduled_for: Union[str, datetime.datetime, NoneType] = None, stop_at: Union[str, datetime.datetime, NoneType] = None) -> stream_chat.types.stream_response.StreamResponse |
727,606 | stream_chat.client | stop_campaign | null | def stop_campaign(self, campaign_id: str) -> StreamResponse:
return self.post(f"campaigns/{campaign_id}/stop")
| (self, campaign_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,607 | stream_chat.client | test_campaign | null | def test_campaign(self, campaign_id: str, users: Iterable[str]) -> StreamResponse:
return self.post(f"campaigns/{campaign_id}/test", data={"users": users})
| (self, campaign_id: str, users: Iterable[str]) -> stream_chat.types.stream_response.StreamResponse |
727,608 | stream_chat.client | translate_message | null | def translate_message(self, message_id: str, language: str) -> StreamResponse:
return self.post(
f"messages/{message_id}/translate", data={"language": language}
)
| (self, message_id: str, language: str) -> stream_chat.types.stream_response.StreamResponse |
727,609 | stream_chat.client | unban_user | null | def unban_user(self, target_id: str, **options: Any) -> StreamResponse:
params = {"target_user_id": target_id, **options}
return self.delete("moderation/ban", params)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,610 | stream_chat.client | unflag_message | null | def unflag_message(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_message_id": target_id, **options}
return self.post("moderation/unflag", data=data)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,611 | stream_chat.client | unflag_user | null | def unflag_user(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_user_id": target_id, **options}
return self.post("moderation/unflag", data=data)
| (self, target_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,612 | stream_chat.client | unmute_user | null | def unmute_user(self, target_id: str, user_id: str) -> StreamResponse:
data = {"target_id": target_id, "user_id": user_id}
return self.post("moderation/unmute", data=data)
| (self, target_id: str, user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,613 | stream_chat.client | unmute_users | null | def unmute_users(self, target_ids: List[str], user_id: str) -> StreamResponse:
data = {"target_ids": target_ids, "user_id": user_id}
return self.post("moderation/unmute", data=data)
| (self, target_ids: List[str], user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,614 | stream_chat.client | unpin_message | null | def unpin_message(self, message_id: str, user_id: str) -> StreamResponse:
updates = {
"set": {
"pinned": False,
}
}
return self.update_message_partial(message_id, updates, user_id)
| (self, message_id: str, user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,615 | stream_chat.client | unread_counts | null | def unread_counts(self, user_id: str) -> StreamResponse:
return self.get("unread", params={"user_id": user_id})
| (self, user_id: str) -> stream_chat.types.stream_response.StreamResponse |
727,616 | stream_chat.client | unread_counts_batch | null | def unread_counts_batch(self, user_ids: List[str]) -> StreamResponse:
return self.post("unread_batch", data={"user_ids": user_ids})
| (self, user_ids: List[str]) -> stream_chat.types.stream_response.StreamResponse |
727,617 | stream_chat.client | update_app_settings | null | def update_app_settings(self, **settings: Any) -> StreamResponse:
return self.patch("app", data=settings)
| (self, **settings: Any) -> stream_chat.types.stream_response.StreamResponse |
727,618 | stream_chat.client | update_blocklist | null | def update_blocklist(self, name: str, words: Iterable[str]) -> StreamResponse:
return self.put(f"blocklists/{name}", data={"words": words})
| (self, name: str, words: Iterable[str]) -> stream_chat.types.stream_response.StreamResponse |
727,619 | stream_chat.client | update_campaign | null | def update_campaign(self, campaign_id: str, data: CampaignData) -> StreamResponse:
return self.put(f"campaigns/{campaign_id}", data=data)
| (self, campaign_id: str, data: stream_chat.types.campaign.CampaignData) -> stream_chat.types.stream_response.StreamResponse |
727,620 | stream_chat.client | update_channel_type | null | def update_channel_type(self, channel_type: str, **settings: Any) -> StreamResponse:
return self.put(f"channeltypes/{channel_type}", data=settings)
| (self, channel_type: str, **settings: Any) -> stream_chat.types.stream_response.StreamResponse |
727,621 | stream_chat.client | update_command | null | def update_command(self, name: str, **settings: Any) -> StreamResponse:
return self.put(f"commands/{name}", data=settings)
| (self, name: str, **settings: Any) -> stream_chat.types.stream_response.StreamResponse |
727,622 | stream_chat.client | update_message | null | def update_message(self, message: Dict) -> StreamResponse:
if message.get("id") is None:
raise ValueError("message must have an id")
return self.post(f"messages/{message['id']}", data={"message": message})
| (self, message: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,623 | stream_chat.client | update_message_partial | null | def update_message_partial(
self, message_id: str, updates: Dict, user_id: str, **options: Any
) -> StreamResponse:
data = updates.copy()
if user_id:
data["user"] = {"id": user_id}
data.update(options)
return self.put(f"messages/{message_id}", data=data)
| (self, message_id: str, updates: Dict, user_id: str, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,624 | stream_chat.client | update_permission | null | def update_permission(self, id: str, permission: Dict) -> StreamResponse:
return self.put(f"permissions/{id}", data=permission)
| (self, id: str, permission: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,625 | stream_chat.client | update_segment | null | def update_segment(
self, segment_id: str, data: SegmentUpdatableFields
) -> StreamResponse:
return self.put(f"segments/{segment_id}", data=data)
| (self, segment_id: str, data: stream_chat.types.segment.SegmentUpdatableFields) -> stream_chat.types.stream_response.StreamResponse |
727,626 | stream_chat.client | update_user | null | def update_user(self, user: Dict) -> StreamResponse:
warnings.warn(
"This method is deprecated. Use upsert_user instead.",
DeprecationWarning,
stacklevel=2,
)
return self.upsert_user(user)
| (self, user: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,627 | stream_chat.client | update_user_partial | null | def update_user_partial(self, update: Dict) -> StreamResponse:
return self.update_users_partial([update])
| (self, update: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,628 | stream_chat.client | update_users | null | def update_users(self, users: List[Dict]) -> StreamResponse:
warnings.warn(
"This method is deprecated. Use upsert_users instead.",
DeprecationWarning,
stacklevel=2,
)
return self.upsert_users(users)
| (self, users: List[Dict]) -> stream_chat.types.stream_response.StreamResponse |
727,629 | stream_chat.client | update_users_partial | null | def update_users_partial(self, updates: List[Dict]) -> StreamResponse:
return self.patch("users", data={"users": updates})
| (self, updates: List[Dict]) -> stream_chat.types.stream_response.StreamResponse |
727,630 | stream_chat.client | upsert_push_provider | null | def upsert_push_provider(self, push_provider_config: Dict) -> StreamResponse:
return self.post("push_providers", data={"push_provider": push_provider_config})
| (self, push_provider_config: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,631 | stream_chat.client | upsert_user | null | def upsert_user(self, user: Dict) -> StreamResponse:
return self.upsert_users([user])
| (self, user: Dict) -> stream_chat.types.stream_response.StreamResponse |
727,632 | stream_chat.client | upsert_users | null | def upsert_users(self, users: List[Dict]) -> StreamResponse:
return self.post("users", data={"users": {u["id"]: u for u in users}})
| (self, users: List[Dict]) -> stream_chat.types.stream_response.StreamResponse |
727,633 | stream_chat.base.client | verify_webhook |
Verify the signature added to a webhook event
:param request_body: the request body received from webhook
:param x_signature: the x-signature header included in the request
:return: bool
| def verify_webhook(
self, request_body: bytes, x_signature: Union[str, bytes]
) -> bool:
"""
Verify the signature added to a webhook event
:param request_body: the request body received from webhook
:param x_signature: the x-signature header included in the request
:return: bool
"""
if isinstance(x_signature, bytes):
x_signature = x_signature.decode()
signature = hmac.new(
key=self.api_secret.encode(), msg=request_body, digestmod=hashlib.sha256
).hexdigest()
return signature == x_signature
| (self, request_body: bytes, x_signature: Union[str, bytes]) -> bool |
727,634 | stream_chat.async_chat.client | StreamChatAsync | null | class StreamChatAsync(StreamChatInterface, AsyncContextManager):
def __init__(
self, api_key: str, api_secret: str, timeout: float = 6.0, **options: Any
):
super().__init__(
api_key=api_key, api_secret=api_secret, timeout=timeout, **options
)
self.session = aiohttp.ClientSession(
base_url=self.base_url,
connector=aiohttp.TCPConnector(keepalive_timeout=59.0),
)
def set_http_session(self, session: aiohttp.ClientSession) -> None:
"""
You can use your own `aiohttp.ClientSession` instance. This instance
will be used for underlying HTTP requests.
Make sure you set up a `base_url` for the session.
"""
self.session = session
async def _parse_response(self, response: aiohttp.ClientResponse) -> StreamResponse:
text = await response.text()
try:
parsed_result = await response.json() if text else {}
except aiohttp.ClientResponseError:
raise StreamAPIException(text, response.status)
if response.status >= 399:
raise StreamAPIException(text, response.status)
return StreamResponse(parsed_result, dict(response.headers), response.status)
async def _make_request(
self,
method: Callable,
relative_url: str,
params: Dict = None,
data: Any = None,
) -> StreamResponse:
params = params or {}
params = {
k: str(v).lower() if isinstance(v, bool) else v for k, v in params.items()
}
data = data or {}
serialized = None
default_params = self.get_default_params()
default_params.update(params)
headers = get_default_header()
headers["Authorization"] = self.auth_token
headers["stream-auth-type"] = "jwt"
if method.__name__ in ["post", "put", "patch"]:
serialized = json.dumps(data)
async with method(
"/" + relative_url.lstrip("/"),
data=serialized,
headers=headers,
params=default_params,
timeout=self.timeout,
) as response:
return await self._parse_response(response)
async def put(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return await self._make_request(self.session.put, relative_url, params, data)
async def post(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return await self._make_request(self.session.post, relative_url, params, data)
async def get(self, relative_url: str, params: Dict = None) -> StreamResponse:
return await self._make_request(self.session.get, relative_url, params, None)
async def delete(self, relative_url: str, params: Dict = None) -> StreamResponse:
return await self._make_request(self.session.delete, relative_url, params, None)
async def patch(
self, relative_url: str, params: Dict = None, data: Any = None
) -> StreamResponse:
return await self._make_request(self.session.patch, relative_url, params, data)
async def update_app_settings(self, **settings: Any) -> StreamResponse:
return await self.patch("app", data=settings)
async def get_app_settings(self) -> StreamResponse:
return await self.get("app")
async def update_users(self, users: List[Dict]) -> StreamResponse:
warnings.warn(
"This method is deprecated. Use upsert_users instead.",
DeprecationWarning,
stacklevel=2,
)
return await self.upsert_users(users)
async def update_user(self, user: Dict) -> StreamResponse:
warnings.warn(
"This method is deprecated. Use upsert_user instead.",
DeprecationWarning,
stacklevel=2,
)
return await self.upsert_user(user)
async def upsert_users(self, users: List[Dict]) -> StreamResponse:
return await self.post("users", data={"users": {u["id"]: u for u in users}})
async def upsert_user(self, user: Dict) -> StreamResponse:
return await self.upsert_users([user])
async def update_users_partial(self, updates: List[Dict]) -> StreamResponse:
return await self.patch("users", data={"users": updates})
async def update_user_partial(self, update: Dict) -> StreamResponse:
return await self.update_users_partial([update])
async def delete_user(self, user_id: str, **options: Any) -> StreamResponse:
return await self.delete(f"users/{user_id}", options)
async def delete_users(
self, user_ids: Iterable[str], delete_type: str, **options: Any
) -> StreamResponse:
return await self.post(
"users/delete", data=dict(options, user=delete_type, user_ids=user_ids)
)
async def restore_users(self, user_ids: Iterable[str]) -> StreamResponse:
return await self.post("users/restore", data={"user_ids": user_ids})
async def deactivate_user(self, user_id: str, **options: Any) -> StreamResponse:
return await self.post(f"users/{user_id}/deactivate", data=options)
async def reactivate_user(self, user_id: str, **options: Any) -> StreamResponse:
return await self.post(f"users/{user_id}/reactivate", data=options)
async def export_user(self, user_id: str, **options: Any) -> StreamResponse:
return await self.get(f"users/{user_id}/export", options)
async def ban_user(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_user_id": target_id, **options}
return await self.post("moderation/ban", data=data)
async def shadow_ban(self, target_id: str, **options: Any) -> StreamResponse:
return await self.ban_user(target_id, shadow=True, **options)
async def remove_shadow_ban(self, target_id: str, **options: Any) -> StreamResponse:
return await self.unban_user(target_id, shadow=True, **options)
async def unban_user(self, target_id: str, **options: Any) -> StreamResponse:
params = {"target_user_id": target_id, **options}
return await self.delete("moderation/ban", params)
async def query_banned_users(self, query_conditions: Dict) -> StreamResponse:
return await self.get(
"query_banned_users", params={"payload": json.dumps(query_conditions)}
)
async def run_message_action(self, message_id: str, data: Dict) -> StreamResponse:
return await self.post(f"messages/{message_id}/action", data=data)
async def flag_message(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_message_id": target_id, **options}
return await self.post("moderation/flag", data=data)
async def unflag_message(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_message_id": target_id, **options}
return await self.post("moderation/unflag", data=data)
async def query_message_flags(
self, filter_conditions: Dict, **options: Any
) -> StreamResponse:
params = {
**options,
"filter_conditions": filter_conditions,
}
return await self.get(
"moderation/flags/message", params={"payload": json.dumps(params)}
)
async def flag_user(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_user_id": target_id, **options}
return await self.post("moderation/flag", data=data)
async def unflag_user(self, target_id: str, **options: Any) -> StreamResponse:
data = {"target_user_id": target_id, **options}
return await self.post("moderation/unflag", data=data)
async def _query_flag_reports(self, **options: Any) -> StreamResponse:
"""
Note: Do not use this.
It is present for internal usage only.
This function can, and will, break and/or be removed at any point in time.
"""
data = {"filter_conditions": options}
return await self.post("moderation/reports", data=data)
async def _review_flag_report(
self, report_id: str, review_result: str, user_id: str, **details: Any
) -> StreamResponse:
"""
Note: Do not use this.
It is present for internal usage only.
This function can, and will, break and/or be removed at any point in time.
"""
data = {
"review_result": review_result,
"user_id": user_id,
"review_details": details,
}
return await self.patch(f"moderation/reports/{report_id}", data=data)
async def mute_users(
self, target_ids: List[str], user_id: str, **options: Any
) -> StreamResponse:
data = {"target_ids": target_ids, "user_id": user_id, **options}
return await self.post("moderation/mute", data=data)
async def mute_user(
self, target_id: str, user_id: str, **options: Any
) -> StreamResponse:
data = {"target_id": target_id, "user_id": user_id, **options}
return await self.post("moderation/mute", data=data)
async def unmute_user(self, target_id: str, user_id: str) -> StreamResponse:
data = {"target_id": target_id, "user_id": user_id}
return await self.post("moderation/unmute", data=data)
async def unmute_users(self, target_ids: List[str], user_id: str) -> StreamResponse:
data = {"target_ids": target_ids, "user_id": user_id}
return await self.post("moderation/unmute", data=data)
async def mark_all_read(self, user_id: str) -> StreamResponse:
return await self.post("channels/read", data={"user": {"id": user_id}})
async def translate_message(self, message_id: str, language: str) -> StreamResponse:
return await self.post(
f"messages/{message_id}/translate", data={"language": language}
)
async def pin_message(
self, message_id: str, user_id: str, expiration: int = None
) -> StreamResponse:
updates = {
"set": {
"pinned": True,
"pin_expires": expiration,
}
}
return await self.update_message_partial(message_id, updates, user_id)
async def unpin_message(self, message_id: str, user_id: str) -> StreamResponse:
updates = {
"set": {
"pinned": False,
}
}
return await self.update_message_partial(message_id, updates, user_id)
async def update_message(self, message: Dict) -> StreamResponse:
if message.get("id") is None:
raise ValueError("message must have an id")
return await self.post(f"messages/{message['id']}", data={"message": message})
async def update_message_partial(
self, message_id: str, updates: Dict, user_id: str, **options: Any
) -> StreamResponse:
data = updates.copy()
if user_id:
data["user"] = {"id": user_id}
data.update(options)
return await self.put(f"messages/{message_id}", data=data)
async def delete_message(self, message_id: str, **options: Any) -> StreamResponse:
return await self.delete(f"messages/{message_id}", options)
async def get_message(self, message_id: str, **options: Any) -> StreamResponse:
return await self.get(f"messages/{message_id}", options)
async def query_users(
self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
) -> StreamResponse:
params = options.copy()
params.update(
{"filter_conditions": filter_conditions, "sort": self.normalize_sort(sort)}
)
return await self.get("users", params={"payload": json.dumps(params)})
async def query_channels(
self, filter_conditions: Dict, sort: List[Dict] = None, **options: Any
) -> StreamResponse:
params: Dict[str, Any] = {"state": True, "watch": False, "presence": False}
params.update(options)
params.update(
{"filter_conditions": filter_conditions, "sort": self.normalize_sort(sort)}
)
return await self.post("channels", data=params)
async def create_channel_type(self, data: Dict) -> StreamResponse:
if "commands" not in data or not data["commands"]:
data["commands"] = ["all"]
return await self.post("channeltypes", data=data)
async def get_channel_type(self, channel_type: str) -> StreamResponse:
return await self.get(f"channeltypes/{channel_type}")
async def list_channel_types(self) -> StreamResponse:
return await self.get("channeltypes")
async def update_channel_type(
self, channel_type: str, **settings: Any
) -> StreamResponse:
return await self.put(f"channeltypes/{channel_type}", data=settings)
async def delete_channel_type(self, channel_type: str) -> StreamResponse:
return await self.delete(f"channeltypes/{channel_type}")
def channel( # type: ignore
self, channel_type: str, channel_id: str = None, data: Dict = None
) -> Channel:
return Channel(self, channel_type, channel_id, data)
async def delete_channels(
self, cids: Iterable[str], **options: Any
) -> StreamResponse:
return await self.post("channels/delete", data=dict(options, cids=cids))
async def list_commands(self) -> StreamResponse:
return await self.get("commands")
async def create_command(self, data: Dict) -> StreamResponse:
return await self.post("commands", data=data)
async def delete_command(self, name: str) -> StreamResponse:
return await self.delete(f"commands/{name}")
async def get_command(self, name: str) -> StreamResponse:
return await self.get(f"commands/{name}")
async def update_command(self, name: str, **settings: Any) -> StreamResponse:
return await self.put(f"commands/{name}", data=settings)
async def add_device(
self,
device_id: str,
push_provider: str,
user_id: str,
push_provider_name: str = None,
) -> StreamResponse:
return await self.post(
"devices",
data={
"id": device_id,
"push_provider": push_provider,
"user_id": user_id,
"push_provider_name": push_provider_name,
},
)
async def delete_device(self, device_id: str, user_id: str) -> StreamResponse:
return await self.delete("devices", {"id": device_id, "user_id": user_id})
async def get_devices(self, user_id: str) -> StreamResponse:
return await self.get("devices", {"user_id": user_id})
async def get_rate_limits(
self,
server_side: bool = False,
android: bool = False,
ios: bool = False,
web: bool = False,
endpoints: Iterable[str] = None,
) -> StreamResponse:
params = {}
if server_side:
params["server_side"] = "true"
if android:
params["android"] = "true"
if ios:
params["ios"] = "true"
if web:
params["web"] = "true"
if endpoints:
params["endpoints"] = ",".join(endpoints)
return await self.get("rate_limits", params)
async def search(
self,
filter_conditions: Dict,
query: Union[str, Dict],
sort: List[Dict] = None,
**options: Any,
) -> StreamResponse:
if "offset" in options:
if sort or "next" in options:
raise ValueError("cannot use offset with sort or next parameters")
params = self.create_search_params(filter_conditions, query, sort, **options)
return await self.get("search", params={"payload": json.dumps(params)})
async def send_file(
self, uri: str, url: str, name: str, user: Dict, content_type: str = None
) -> StreamResponse:
headers = {
"Authorization": self.auth_token,
"stream-auth-type": "jwt",
"X-Stream-Client": get_user_agent(),
}
parts = urlparse(url)
if parts[0] == "":
async with AIOFile(url, "rb") as f:
content = await f.read()
else:
async with self.session.get(
url, headers={"User-Agent": "Mozilla/5.0"}
) as content_response:
content = await content_response.read()
data = FormData()
data.add_field("user", json.dumps(user))
data.add_field("file", content, filename=name, content_type=content_type)
async with self.session.post(
"/" + uri.lstrip("/"),
params=self.get_default_params(),
data=data,
headers=headers,
) as response:
return await self._parse_response(response)
async def create_blocklist(
self, name: str, words: Iterable[str], type: str = "word"
) -> StreamResponse:
return await self.post(
"blocklists", data={"name": name, "words": words, "type": type}
)
async def list_blocklists(self) -> StreamResponse:
return await self.get("blocklists")
async def get_blocklist(self, name: str) -> StreamResponse:
return await self.get(f"blocklists/{name}")
async def update_blocklist(self, name: str, words: Iterable[str]) -> StreamResponse:
return await self.put(f"blocklists/{name}", data={"words": words})
async def delete_blocklist(self, name: str) -> StreamResponse:
return await self.delete(f"blocklists/{name}")
async def check_push(self, push_data: Dict) -> StreamResponse:
return await self.post("check_push", data=push_data)
async def check_sqs(
self, sqs_key: str = None, sqs_secret: str = None, sqs_url: str = None
) -> StreamResponse:
data = {"sqs_key": sqs_key, "sqs_secret": sqs_secret, "sqs_url": sqs_url}
return await self.post("check_sqs", data=data)
async def check_sns(
self, sns_key: str = None, sns_secret: str = None, sns_topic_arn: str = None
) -> StreamResponse:
data = {
"sns_key": sns_key,
"sns_secret": sns_secret,
"sns_topic_arn": sns_topic_arn,
}
return await self.post("check_sns", data=data)
async def set_guest_user(self, guest_user: Dict) -> StreamResponse:
return await self.post("guest", data=dict(user=guest_user))
async def get_permission(self, id: str) -> StreamResponse:
return await self.get(f"permissions/{id}")
async def create_permission(self, permission: Dict) -> StreamResponse:
return await self.post("permissions", data=permission)
async def update_permission(self, id: str, permission: Dict) -> StreamResponse:
return await self.put(f"permissions/{id}", data=permission)
async def delete_permission(self, id: str) -> StreamResponse:
return await self.delete(f"permissions/{id}")
async def list_permissions(self) -> StreamResponse:
return await self.get("permissions")
async def create_role(self, name: str) -> StreamResponse:
return await self.post("roles", data={"name": name})
async def delete_role(self, name: str) -> StreamResponse:
return await self.delete(f"roles/{name}")
async def list_roles(self) -> StreamResponse:
return await self.get("roles")
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 get_segment(self, segment_id: str) -> StreamResponse:
return await self.get(f"segments/{segment_id}")
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: SegmentUpdatableFields
) -> 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 segment_target_exists(
self, segment_id: str, target_id: str
) -> StreamResponse:
return await self.get(f"segments/{segment_id}/target/{target_id}")
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 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}
)
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 create_campaign(
self, campaign_id: Optional[str] = None, data: Optional[CampaignData] = None
) -> StreamResponse:
payload = {"id": campaign_id}
if data is not None:
payload.update(cast(dict, data))
return await self.post("campaigns", data=payload)
async def get_campaign(self, campaign_id: str) -> StreamResponse:
return await self.get(f"campaigns/{campaign_id}")
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 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]
) -> StreamResponse:
return await self.post(f"campaigns/{campaign_id}/test", data={"users": users})
async def revoke_tokens(
self, since: Union[str, datetime.datetime]
) -> StreamResponse:
if isinstance(since, datetime.datetime):
since = since.isoformat()
return await self.update_app_settings(revoke_tokens_issued_before=since)
async def revoke_user_token(
self, user_id: str, before: Union[str, datetime.datetime]
) -> StreamResponse:
return await self.revoke_users_token([user_id], before)
async def revoke_users_token(
self, user_ids: Iterable[str], before: Union[str, datetime.datetime]
) -> StreamResponse:
if isinstance(before, datetime.datetime):
before = before.isoformat()
updates = []
for user_id in user_ids:
updates.append(
{"id": user_id, "set": {"revoke_tokens_issued_before": before}}
)
return await self.update_users_partial(updates)
async def export_channel(
self,
channel_type: str,
channel_id: str,
messages_since: Union[str, datetime.datetime] = None,
messages_until: Union[str, datetime.datetime] = None,
**options: Any,
) -> StreamResponse:
if isinstance(messages_since, datetime.datetime):
messages_since = messages_since.isoformat()
if isinstance(messages_until, datetime.datetime):
messages_until = messages_until.isoformat()
return await self.export_channels(
[
{
"id": channel_id,
"type": channel_type,
"messages_since": messages_since,
"messages_until": messages_until,
}
],
**options,
)
async def export_channels(
self, channels: Iterable[Dict], **options: Any
) -> StreamResponse:
return await self.post(
"export_channels", data={"channels": channels, **options}
)
async def get_export_channel_status(self, task_id: str) -> StreamResponse:
return await self.get(f"export_channels/{task_id}")
async def get_task(self, task_id: str) -> StreamResponse:
return await self.get(f"tasks/{task_id}")
async def send_user_custom_event(self, user_id: str, event: Dict) -> StreamResponse:
return await self.post(f"users/{user_id}/event", data={"event": event})
async def upsert_push_provider(self, push_provider_config: Dict) -> StreamResponse:
return await self.post(
"push_providers", data={"push_provider": push_provider_config}
)
async def delete_push_provider(
self, provider_type: str, name: str
) -> StreamResponse:
return await self.delete(f"push_providers/{provider_type}/{name}")
async def list_push_providers(self) -> StreamResponse:
return await self.get("push_providers")
async def create_import_url(self, filename: str) -> StreamResponse:
return await self.post("import_urls", data={"filename": filename})
async def create_import(
self, path: str, mode: Literal["insert", "upsert"] = "upsert"
) -> StreamResponse:
return await self.post("imports", data={"path": path, "mode": mode})
async def get_import(self, id: str) -> StreamResponse:
return await self.get(f"imports/{id}")
async def list_imports(self, options: Dict = None) -> StreamResponse:
return await self.get("imports", params=options)
async def unread_counts(self, user_id: str) -> StreamResponse:
return await self.get("unread", params={"user_id": user_id})
async def unread_counts_batch(self, user_ids: List[str]) -> StreamResponse:
return await self.post("unread_batch", data={"user_ids": user_ids})
async def close(self) -> None:
await self.session.close()
async def __aenter__(self) -> "StreamChatAsync":
return self
async def __aexit__(
self,
exc_type: Optional[Type[BaseException]],
exc_val: Optional[BaseException],
exc_tb: Optional[TracebackType],
) -> None:
await self.close()
| (api_key: str, api_secret: str, timeout: float = 6.0, **options: Any) |
727,637 | stream_chat.async_chat.client | __init__ | null | def __init__(
self, api_key: str, api_secret: str, timeout: float = 6.0, **options: Any
):
super().__init__(
api_key=api_key, api_secret=api_secret, timeout=timeout, **options
)
self.session = aiohttp.ClientSession(
base_url=self.base_url,
connector=aiohttp.TCPConnector(keepalive_timeout=59.0),
)
| (self, api_key: str, api_secret: str, timeout: float = 6.0, **options: Any) |
727,638 | stream_chat.async_chat.client | _make_request | null | def set_http_session(self, session: aiohttp.ClientSession) -> None:
"""
You can use your own `aiohttp.ClientSession` instance. This instance
will be used for underlying HTTP requests.
Make sure you set up a `base_url` for the session.
"""
self.session = session
| (self, method: Callable, relative_url: str, params: Optional[Dict] = None, data: Optional[Any] = None) -> stream_chat.types.stream_response.StreamResponse |
727,640 | stream_chat.async_chat.client | _query_flag_reports |
Note: Do not use this.
It is present for internal usage only.
This function can, and will, break and/or be removed at any point in time.
| def set_http_session(self, session: aiohttp.ClientSession) -> None:
"""
You can use your own `aiohttp.ClientSession` instance. This instance
will be used for underlying HTTP requests.
Make sure you set up a `base_url` for the session.
"""
self.session = session
| (self, **options: Any) -> stream_chat.types.stream_response.StreamResponse |
727,733 | stream_chat.async_chat.client | set_http_session |
You can use your own `aiohttp.ClientSession` instance. This instance
will be used for underlying HTTP requests.
Make sure you set up a `base_url` for the session.
| def set_http_session(self, session: aiohttp.ClientSession) -> None:
"""
You can use your own `aiohttp.ClientSession` instance. This instance
will be used for underlying HTTP requests.
Make sure you set up a `base_url` for the session.
"""
self.session = session
| (self, session: aiohttp.client.ClientSession) -> NoneType |
727,773 | openxlab.xlab.handler.user_login | login | null | def login(ak, sk, re_login=False, relogin=False):
if os.path.exists(get_config_path()) and re_login is False and relogin is False:
logger.warning("AK and SK have been configured. You can set relogin as true to force a relogin.")
get_token_via_api(ak, sk)
user_config = UserConfig(ak, sk)
user_config.store_to_local()
| (ak, sk, re_login=False, relogin=False) |
727,777 | fysom | Canceled |
Raised when an event is canceled due to the
onbeforeevent handler returning False
| class Canceled(FysomError):
'''
Raised when an event is canceled due to the
onbeforeevent handler returning False
'''
| (msg, event=None) |
727,778 | fysom | __init__ | null | def __init__(self, msg, event=None):
super(FysomError, self).__init__(msg)
self.event = event
| (self, msg, event=None) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.