circle-so-python-sdk 0.1.0__py3-none-any.whl

circle/api/admin_misc.py

@@ -0,0 +1,305 @@
+"""Admin API -- Forms, Segments, Invitations, and Misc endpoints."""
+from __future__ import annotations
+from typing import Any, Dict, List, Optional, Tuple
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.misc import (
+    Form, FormList, FormSubmission, FormSubmissionList,
+    CommunitySegment, CommunitySegmentList, InvitationLink, InvitationLinkList,
+    Embed, DirectUpload, LiveRoom, LiveRoomList,
+    FlaggedContent, FlaggedContentList, LeaderboardMember, AdvancedSearchResults,
+)
+from circle.models.admin.community import ChatPreferences
+
+_Req = Tuple[str, str, Dict[str, Any]]
+
+
+# -- Param helpers --
+
+def _list_forms_req(page: int, per_page: int, name: Optional[str]) -> _Req:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if name:
+        p["name"] = name
+    return "GET", f"{_P}/forms", {"params": p}
+
+
+def _list_community_segments_req(page: int, per_page: int, title: Optional[str]) -> _Req:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if title:
+        p["title"] = title
+    return "GET", f"{_P}/community_segments", {"params": p}
+
+
+def _list_invitation_links_req(page: int, per_page: int, name: Optional[str],
+                                status: Optional[str]) -> _Req:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if name:
+        p["name"] = name
+    if status:
+        p["status"] = status
+    return "GET", f"{_P}/invitation_links", {"params": p}
+
+
+def _list_flagged_contents_req(page: int, per_page: int, status: Optional[str]) -> _Req:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if status:
+        p["status"] = status
+    return "GET", f"{_P}/flagged_contents", {"params": p}
+
+
+def _advanced_search_req(query: str, page: int, per_page: int,
+                          type: Optional[str], kwargs: Dict[str, Any]) -> _Req:
+    p: Dict[str, Any] = {"query": query, "page": page, "per_page": per_page, **kwargs}
+    if type:
+        p["type"] = type
+    return "GET", f"{_P}/advanced_search", {"params": p}
+
+
+# ---------------------------------------------------------------------------
+# Sync client
+# ---------------------------------------------------------------------------
+
+class AdminMiscClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    # -- Forms --
+    def list_forms(self, *, page: int = 1, per_page: int = 60, name: Optional[str] = None) -> FormList:
+        m, p, kw = _list_forms_req(page, per_page, name)
+        return FormList.model_validate(self._t.request(m, p, **kw))
+
+    def show_form(self, form_id: int) -> Form:
+        return Form.model_validate(self._t.request("GET", f"{_P}/forms/{form_id}"))
+
+    def update_form(self, form_id: int, **kwargs: Any) -> Form:
+        return Form.model_validate(self._t.request("PUT", f"{_P}/forms/{form_id}", json=kwargs))
+
+    def delete_form(self, form_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/forms/{form_id}")
+
+    def duplicate_form(self, form_id: int) -> Form:
+        return Form.model_validate(self._t.request("POST", f"{_P}/forms/{form_id}/duplicate"))
+
+    def list_form_submissions(self, form_id: int, *, page: int = 1, per_page: int = 10) -> FormSubmissionList:
+        return FormSubmissionList.model_validate(
+            self._t.request("GET", f"{_P}/forms/{form_id}/submissions",
+                            params={"page": page, "per_page": per_page}))
+
+    def create_form_submission(self, form_id: int, *, elements: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return self._t.request("POST", f"{_P}/forms/{form_id}/submissions", json={"elements": elements})
+
+    # -- Community Segments --
+    def list_community_segments(self, *, page: int = 1, per_page: int = 60,
+                                title: Optional[str] = None) -> CommunitySegmentList:
+        m, p, kw = _list_community_segments_req(page, per_page, title)
+        return CommunitySegmentList.model_validate(self._t.request(m, p, **kw))
+
+    def create_community_segment(self, **kwargs: Any) -> CommunitySegment:
+        return CommunitySegment.model_validate(self._t.request("POST", f"{_P}/community_segments", json=kwargs))
+
+    def update_community_segment(self, segment_id: int, **kwargs: Any) -> CommunitySegment:
+        return CommunitySegment.model_validate(
+            self._t.request("PUT", f"{_P}/community_segments/{segment_id}", json=kwargs))
+
+    def delete_community_segment(self, segment_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/community_segments/{segment_id}")
+
+    def duplicate_community_segment(self, segment_id: int, *, title: str) -> CommunitySegment:
+        return CommunitySegment.model_validate(
+            self._t.request("POST", f"{_P}/community_segments/{segment_id}/duplicate", params={"title": title}))
+
+    # -- Invitation Links --
+    def list_invitation_links(self, *, page: int = 1, per_page: int = 10, name: Optional[str] = None,
+                              status: Optional[str] = None) -> InvitationLinkList:
+        m, p, kw = _list_invitation_links_req(page, per_page, name, status)
+        return InvitationLinkList.model_validate(self._t.request(m, p, **kw))
+
+    def delete_invitation_link(self, link_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/invitation_links/{link_id}")
+
+    def revoke_invitation_link(self, link_id: int) -> Dict[str, Any]:
+        return self._t.request("PATCH", f"{_P}/invitation_links/{link_id}/revoke")
+
+    # -- Chat Preferences --
+    def update_chat_preferences(self, **kwargs: Any) -> ChatPreferences:
+        return ChatPreferences.model_validate(self._t.request("PUT", f"{_P}/chat_preferences", json=kwargs))
+
+    # -- Direct Uploads --
+    def create_direct_upload(self, *, blob: Dict[str, Any]) -> DirectUpload:
+        return DirectUpload.model_validate(self._t.request("POST", f"{_P}/direct_uploads", json={"blob": blob}))
+
+    # -- Embeds --
+    def create_embed(self, *, url: str) -> Embed:
+        return Embed.model_validate(self._t.request("POST", f"{_P}/embeds", json={"url": url}))
+
+    def get_embed(self, sgid: str) -> Embed:
+        return Embed.model_validate(self._t.request("GET", f"{_P}/embeds/{sgid}"))
+
+    # -- Messages --
+    def create_message(self, *, rich_text_body: Dict[str, Any],
+                       user_email: Optional[str] = None, user_emails: Optional[List[str]] = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"rich_text_body": rich_text_body}
+        if user_email:
+            body["user_email"] = user_email
+        if user_emails:
+            body["user_emails"] = user_emails
+        return self._t.request("POST", f"{_P}/messages", json=body)
+
+    # -- Advanced Search --
+    def advanced_search(self, *, query: str, page: int = 1, per_page: int = 20,
+                        type: Optional[str] = None, **kwargs: Any) -> AdvancedSearchResults:
+        m, p, kw = _advanced_search_req(query, page, per_page, type, kwargs)
+        return AdvancedSearchResults.model_validate(self._t.request(m, p, **kw))
+
+    # -- Leaderboard --
+    def get_leaderboard(self, *, period: Optional[str] = None) -> List[LeaderboardMember]:
+        p: Dict[str, Any] = {}
+        if period:
+            p["period"] = period
+        data = self._t.request("GET", f"{_P}/gamification/leaderboard", params=p)
+        return [LeaderboardMember.model_validate(r) for r in data]
+
+    # -- Flagged Contents --
+    def list_flagged_contents(self, *, page: int = 1, per_page: int = 10,
+                              status: Optional[str] = None) -> FlaggedContentList:
+        m, p, kw = _list_flagged_contents_req(page, per_page, status)
+        return FlaggedContentList.model_validate(self._t.request(m, p, **kw))
+
+    def report_flagged_content(self, **kwargs: Any) -> FlaggedContent:
+        return FlaggedContent.model_validate(
+            self._t.request("POST", f"{_P}/flagged_contents", json={"flagged_content": kwargs}))
+
+    # -- Live Rooms --
+    def list_live_rooms(self, *, page: int = 1, per_page: int = 20) -> LiveRoomList:
+        return LiveRoomList.model_validate(
+            self._t.request("GET", f"{_P}/live/rooms", params={"page": page, "per_page": per_page}))
+
+    def list_live_room_transcripts(self, room_id: int) -> Dict[str, Any]:
+        return self._t.request("GET", f"{_P}/live/rooms/{room_id}/transcripts")
+
+
+# ---------------------------------------------------------------------------
+# Async client
+# ---------------------------------------------------------------------------
+
+class AsyncAdminMiscClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    # -- Forms --
+    async def list_forms(self, *, page: int = 1, per_page: int = 60, name: Optional[str] = None) -> FormList:
+        m, p, kw = _list_forms_req(page, per_page, name)
+        return FormList.model_validate(await self._t.request(m, p, **kw))
+
+    async def show_form(self, form_id: int) -> Form:
+        return Form.model_validate(await self._t.request("GET", f"{_P}/forms/{form_id}"))
+
+    async def update_form(self, form_id: int, **kwargs: Any) -> Form:
+        return Form.model_validate(await self._t.request("PUT", f"{_P}/forms/{form_id}", json=kwargs))
+
+    async def delete_form(self, form_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/forms/{form_id}")
+
+    async def duplicate_form(self, form_id: int) -> Form:
+        return Form.model_validate(await self._t.request("POST", f"{_P}/forms/{form_id}/duplicate"))
+
+    async def list_form_submissions(self, form_id: int, *, page: int = 1, per_page: int = 10) -> FormSubmissionList:
+        return FormSubmissionList.model_validate(
+            await self._t.request("GET", f"{_P}/forms/{form_id}/submissions",
+                                  params={"page": page, "per_page": per_page}))
+
+    async def create_form_submission(self, form_id: int, *, elements: List[Dict[str, Any]]) -> Dict[str, Any]:
+        return await self._t.request("POST", f"{_P}/forms/{form_id}/submissions", json={"elements": elements})
+
+    # -- Community Segments --
+    async def list_community_segments(self, *, page: int = 1, per_page: int = 60,
+                                      title: Optional[str] = None) -> CommunitySegmentList:
+        m, p, kw = _list_community_segments_req(page, per_page, title)
+        return CommunitySegmentList.model_validate(await self._t.request(m, p, **kw))
+
+    async def create_community_segment(self, **kwargs: Any) -> CommunitySegment:
+        return CommunitySegment.model_validate(
+            await self._t.request("POST", f"{_P}/community_segments", json=kwargs))
+
+    async def update_community_segment(self, segment_id: int, **kwargs: Any) -> CommunitySegment:
+        return CommunitySegment.model_validate(
+            await self._t.request("PUT", f"{_P}/community_segments/{segment_id}", json=kwargs))
+
+    async def delete_community_segment(self, segment_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/community_segments/{segment_id}")
+
+    async def duplicate_community_segment(self, segment_id: int, *, title: str) -> CommunitySegment:
+        return CommunitySegment.model_validate(
+            await self._t.request("POST", f"{_P}/community_segments/{segment_id}/duplicate",
+                                  params={"title": title}))
+
+    # -- Invitation Links --
+    async def list_invitation_links(self, *, page: int = 1, per_page: int = 10, name: Optional[str] = None,
+                                    status: Optional[str] = None) -> InvitationLinkList:
+        m, p, kw = _list_invitation_links_req(page, per_page, name, status)
+        return InvitationLinkList.model_validate(await self._t.request(m, p, **kw))
+
+    async def delete_invitation_link(self, link_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/invitation_links/{link_id}")
+
+    async def revoke_invitation_link(self, link_id: int) -> Dict[str, Any]:
+        return await self._t.request("PATCH", f"{_P}/invitation_links/{link_id}/revoke")
+
+    # -- Chat Preferences --
+    async def update_chat_preferences(self, **kwargs: Any) -> ChatPreferences:
+        return ChatPreferences.model_validate(await self._t.request("PUT", f"{_P}/chat_preferences", json=kwargs))
+
+    # -- Direct Uploads --
+    async def create_direct_upload(self, *, blob: Dict[str, Any]) -> DirectUpload:
+        return DirectUpload.model_validate(
+            await self._t.request("POST", f"{_P}/direct_uploads", json={"blob": blob}))
+
+    # -- Embeds --
+    async def create_embed(self, *, url: str) -> Embed:
+        return Embed.model_validate(await self._t.request("POST", f"{_P}/embeds", json={"url": url}))
+
+    async def get_embed(self, sgid: str) -> Embed:
+        return Embed.model_validate(await self._t.request("GET", f"{_P}/embeds/{sgid}"))
+
+    # -- Messages --
+    async def create_message(self, *, rich_text_body: Dict[str, Any],
+                             user_email: Optional[str] = None,
+                             user_emails: Optional[List[str]] = None) -> Dict[str, Any]:
+        body: Dict[str, Any] = {"rich_text_body": rich_text_body}
+        if user_email:
+            body["user_email"] = user_email
+        if user_emails:
+            body["user_emails"] = user_emails
+        return await self._t.request("POST", f"{_P}/messages", json=body)
+
+    # -- Advanced Search --
+    async def advanced_search(self, *, query: str, page: int = 1, per_page: int = 20,
+                              type: Optional[str] = None, **kwargs: Any) -> AdvancedSearchResults:
+        m, p, kw = _advanced_search_req(query, page, per_page, type, kwargs)
+        return AdvancedSearchResults.model_validate(await self._t.request(m, p, **kw))
+
+    # -- Leaderboard --
+    async def get_leaderboard(self, *, period: Optional[str] = None) -> List[LeaderboardMember]:
+        p: Dict[str, Any] = {}
+        if period:
+            p["period"] = period
+        data = await self._t.request("GET", f"{_P}/gamification/leaderboard", params=p)
+        return [LeaderboardMember.model_validate(r) for r in data]
+
+    # -- Flagged Contents --
+    async def list_flagged_contents(self, *, page: int = 1, per_page: int = 10,
+                                    status: Optional[str] = None) -> FlaggedContentList:
+        m, p, kw = _list_flagged_contents_req(page, per_page, status)
+        return FlaggedContentList.model_validate(await self._t.request(m, p, **kw))
+
+    async def report_flagged_content(self, **kwargs: Any) -> FlaggedContent:
+        return FlaggedContent.model_validate(
+            await self._t.request("POST", f"{_P}/flagged_contents", json={"flagged_content": kwargs}))
+
+    # -- Live Rooms --
+    async def list_live_rooms(self, *, page: int = 1, per_page: int = 20) -> LiveRoomList:
+        return LiveRoomList.model_validate(
+            await self._t.request("GET", f"{_P}/live/rooms", params={"page": page, "per_page": per_page}))
+
+    async def list_live_room_transcripts(self, room_id: int) -> Dict[str, Any]:
+        return await self._t.request("GET", f"{_P}/live/rooms/{room_id}/transcripts")

circle/api/admin_posts.py

@@ -0,0 +1,200 @@
+"""Admin API -- Posts, Comments, Topics."""
+from __future__ import annotations
+from typing import Any, Dict, Optional
+from circle.constants import ADMIN_V2_PREFIX as _P
+from circle.http import AsyncTransport, SyncTransport
+from circle.models.admin.posts import (
+    BasicPost, PostList, BasicPostCreatedResponse, BasicPostUpdatedResponse, BasicPostDeletedResponse,
+    ImagePost, ImagePostCreatedResponse, AISummary, Comment, CommentList, Topic, TopicList,
+)
+
+
+def _list_posts_params(page: int, per_page: int, space_id: Optional[int],
+                       space_group_id: Optional[int], status: Optional[str],
+                       search_text: Optional[str], sort: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if space_id: p["space_id"] = space_id
+    if space_group_id: p["space_group_id"] = space_group_id
+    if status: p["status"] = status
+    if search_text: p["search_text"] = search_text
+    if sort: p["sort"] = sort
+    return p
+
+
+def _list_comments_params(page: int, per_page: int, space_id: Optional[int],
+                          post_id: Optional[int], search_text: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if space_id: p["space_id"] = space_id
+    if post_id: p["post_id"] = post_id
+    if search_text: p["search_text"] = search_text
+    return p
+
+
+def _list_topics_params(page: int, per_page: int, name: Optional[str],
+                        sort: Optional[str]) -> Dict[str, Any]:
+    p: Dict[str, Any] = {"page": page, "per_page": per_page}
+    if name: p["name"] = name
+    if sort: p["sort"] = sort
+    return p
+
+
+class PostsClient:
+    def __init__(self, transport: SyncTransport) -> None:
+        self._t = transport
+
+    # -- Posts --
+    def list_posts(self, *, page: int = 1, per_page: int = 60, space_id: Optional[int] = None,
+                   space_group_id: Optional[int] = None, status: Optional[str] = None,
+                   search_text: Optional[str] = None, sort: Optional[str] = None) -> PostList:
+        return PostList.model_validate(self._t.request(
+            "GET", f"{_P}/posts", params=_list_posts_params(page, per_page, space_id, space_group_id, status, search_text, sort)))
+
+    def create_post(self, *, space_id: int, name: str, **kwargs: Any) -> BasicPostCreatedResponse:
+        return BasicPostCreatedResponse.model_validate(
+            self._t.request("POST", f"{_P}/posts", json={"space_id": space_id, "name": name, **kwargs}))
+
+    def show_post(self, post_id: int) -> BasicPost:
+        return BasicPost.model_validate(self._t.request("GET", f"{_P}/posts/{post_id}"))
+
+    def update_post(self, post_id: int, **kwargs: Any) -> BasicPostUpdatedResponse:
+        return BasicPostUpdatedResponse.model_validate(
+            self._t.request("PUT", f"{_P}/posts/{post_id}", json=kwargs))
+
+    def delete_post(self, post_id: int) -> BasicPostDeletedResponse:
+        return BasicPostDeletedResponse.model_validate(self._t.request("DELETE", f"{_P}/posts/{post_id}"))
+
+    def get_post_summary(self, post_id: int) -> AISummary:
+        return AISummary.model_validate(self._t.request("GET", f"{_P}/posts/{post_id}/summary"))
+
+    # -- Image Posts --
+    def create_image_post(self, space_id: int, **kwargs: Any) -> ImagePostCreatedResponse:
+        return ImagePostCreatedResponse.model_validate(
+            self._t.request("POST", f"{_P}/spaces/{space_id}/images/posts", json=kwargs))
+
+    def delete_image_post(self, space_id: int, post_id: int) -> BasicPostDeletedResponse:
+        return BasicPostDeletedResponse.model_validate(
+            self._t.request("DELETE", f"{_P}/spaces/{space_id}/images/posts/{post_id}"))
+
+    def duplicate_image_post(self, space_id: int, post_id: int, **kwargs: Any) -> ImagePostCreatedResponse:
+        return ImagePostCreatedResponse.model_validate(
+            self._t.request("POST", f"{_P}/spaces/{space_id}/images/posts/{post_id}/duplicate", json=kwargs))
+
+    # -- Post Followers --
+    def unfollow_post(self, post_id: int, *, community_member_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/posts/{post_id}/post_followers",
+                               params={"community_member_id": community_member_id})
+
+    # -- Comments --
+    def list_comments(self, *, page: int = 1, per_page: int = 10, space_id: Optional[int] = None,
+                      post_id: Optional[int] = None, search_text: Optional[str] = None) -> CommentList:
+        return CommentList.model_validate(self._t.request(
+            "GET", f"{_P}/comments", params=_list_comments_params(page, per_page, space_id, post_id, search_text)))
+
+    def create_comment(self, *, body: str, post_id: int, **kwargs: Any) -> Comment:
+        return Comment.model_validate(
+            self._t.request("POST", f"{_P}/comments", json={"body": body, "post_id": post_id, **kwargs}))
+
+    def show_comment(self, comment_id: int) -> Comment:
+        return Comment.model_validate(self._t.request("GET", f"{_P}/comments/{comment_id}"))
+
+    def delete_comment(self, comment_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/comments/{comment_id}")
+
+    # -- Topics --
+    def list_topics(self, *, page: int = 1, per_page: int = 10, name: Optional[str] = None,
+                    sort: Optional[str] = None) -> TopicList:
+        return TopicList.model_validate(self._t.request(
+            "GET", f"{_P}/topics", params=_list_topics_params(page, per_page, name, sort)))
+
+    def create_topic(self, *, name: str, **kwargs: Any) -> Topic:
+        return Topic.model_validate(self._t.request("POST", f"{_P}/topics", json={"name": name, **kwargs}))
+
+    def show_topic(self, topic_id: int) -> Topic:
+        return Topic.model_validate(self._t.request("GET", f"{_P}/topics/{topic_id}"))
+
+    def update_topic(self, topic_id: int, **kwargs: Any) -> Topic:
+        return Topic.model_validate(self._t.request("PUT", f"{_P}/topics/{topic_id}", json=kwargs))
+
+    def delete_topic(self, topic_id: int) -> Dict[str, Any]:
+        return self._t.request("DELETE", f"{_P}/topics/{topic_id}")
+
+
+class AsyncPostsClient:
+    def __init__(self, transport: AsyncTransport) -> None:
+        self._t = transport
+
+    # -- Posts --
+    async def list_posts(self, *, page: int = 1, per_page: int = 60, space_id: Optional[int] = None,
+                         space_group_id: Optional[int] = None, status: Optional[str] = None,
+                         search_text: Optional[str] = None, sort: Optional[str] = None) -> PostList:
+        return PostList.model_validate(await self._t.request(
+            "GET", f"{_P}/posts", params=_list_posts_params(page, per_page, space_id, space_group_id, status, search_text, sort)))
+
+    async def create_post(self, *, space_id: int, name: str, **kwargs: Any) -> BasicPostCreatedResponse:
+        return BasicPostCreatedResponse.model_validate(
+            await self._t.request("POST", f"{_P}/posts", json={"space_id": space_id, "name": name, **kwargs}))
+
+    async def show_post(self, post_id: int) -> BasicPost:
+        return BasicPost.model_validate(await self._t.request("GET", f"{_P}/posts/{post_id}"))
+
+    async def update_post(self, post_id: int, **kwargs: Any) -> BasicPostUpdatedResponse:
+        return BasicPostUpdatedResponse.model_validate(
+            await self._t.request("PUT", f"{_P}/posts/{post_id}", json=kwargs))
+
+    async def delete_post(self, post_id: int) -> BasicPostDeletedResponse:
+        return BasicPostDeletedResponse.model_validate(await self._t.request("DELETE", f"{_P}/posts/{post_id}"))
+
+    async def get_post_summary(self, post_id: int) -> AISummary:
+        return AISummary.model_validate(await self._t.request("GET", f"{_P}/posts/{post_id}/summary"))
+
+    # -- Image Posts --
+    async def create_image_post(self, space_id: int, **kwargs: Any) -> ImagePostCreatedResponse:
+        return ImagePostCreatedResponse.model_validate(
+            await self._t.request("POST", f"{_P}/spaces/{space_id}/images/posts", json=kwargs))
+
+    async def delete_image_post(self, space_id: int, post_id: int) -> BasicPostDeletedResponse:
+        return BasicPostDeletedResponse.model_validate(
+            await self._t.request("DELETE", f"{_P}/spaces/{space_id}/images/posts/{post_id}"))
+
+    async def duplicate_image_post(self, space_id: int, post_id: int, **kwargs: Any) -> ImagePostCreatedResponse:
+        return ImagePostCreatedResponse.model_validate(
+            await self._t.request("POST", f"{_P}/spaces/{space_id}/images/posts/{post_id}/duplicate", json=kwargs))
+
+    # -- Post Followers --
+    async def unfollow_post(self, post_id: int, *, community_member_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/posts/{post_id}/post_followers",
+                                     params={"community_member_id": community_member_id})
+
+    # -- Comments --
+    async def list_comments(self, *, page: int = 1, per_page: int = 10, space_id: Optional[int] = None,
+                            post_id: Optional[int] = None, search_text: Optional[str] = None) -> CommentList:
+        return CommentList.model_validate(await self._t.request(
+            "GET", f"{_P}/comments", params=_list_comments_params(page, per_page, space_id, post_id, search_text)))
+
+    async def create_comment(self, *, body: str, post_id: int, **kwargs: Any) -> Comment:
+        return Comment.model_validate(
+            await self._t.request("POST", f"{_P}/comments", json={"body": body, "post_id": post_id, **kwargs}))
+
+    async def show_comment(self, comment_id: int) -> Comment:
+        return Comment.model_validate(await self._t.request("GET", f"{_P}/comments/{comment_id}"))
+
+    async def delete_comment(self, comment_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/comments/{comment_id}")
+
+    # -- Topics --
+    async def list_topics(self, *, page: int = 1, per_page: int = 10, name: Optional[str] = None,
+                          sort: Optional[str] = None) -> TopicList:
+        return TopicList.model_validate(await self._t.request(
+            "GET", f"{_P}/topics", params=_list_topics_params(page, per_page, name, sort)))
+
+    async def create_topic(self, *, name: str, **kwargs: Any) -> Topic:
+        return Topic.model_validate(await self._t.request("POST", f"{_P}/topics", json={"name": name, **kwargs}))
+
+    async def show_topic(self, topic_id: int) -> Topic:
+        return Topic.model_validate(await self._t.request("GET", f"{_P}/topics/{topic_id}"))
+
+    async def update_topic(self, topic_id: int, **kwargs: Any) -> Topic:
+        return Topic.model_validate(await self._t.request("PUT", f"{_P}/topics/{topic_id}", json=kwargs))
+
+    async def delete_topic(self, topic_id: int) -> Dict[str, Any]:
+        return await self._t.request("DELETE", f"{_P}/topics/{topic_id}")