blueticks 3.3.0__tar.gz → 3.3.2__tar.gz

{blueticks-3.3.0/src/blueticks.egg-info → blueticks-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blueticks
-Version: 3.3.0
+Version: 3.3.2
 Summary: Official Python client for the Blueticks API.
 Author-email: Blueticks <support@blueticks.co>
 License: MIT License

blueticks-3.3.2/src/blueticks/_version.py

@@ -0,0 +1 @@
+__version__ = "3.3.2"

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/resources/audiences.py

@@ -4,6 +4,7 @@ import builtins
 from typing import Any
 
 from blueticks._base_resource import BaseResource
+from blueticks.types._deleted_resource import DeletedResource
 from blueticks.types.audiences import AppendContactsResult, Audience, Contact
 from blueticks.types.page import Page
 
@@ -47,9 +48,14 @@ class AudiencesResource(BaseResource):
         data = self._client._request("PATCH", f"/v1/audiences/{audience_id}", body={"name": name})
         return Audience.model_validate(data)
 
-    def delete(self, audience_id: str) -> None:
-        self._client._request("DELETE", f"/v1/audiences/{audience_id}")
-        return None
+    def delete(self, audience_id: str) -> DeletedResource:
+        """Delete audience.
+
+        Soft-delete an audience. 409 if it`s referenced by an active campaign.
+        Returns the deleted ref. Requires ``audiences:write``.
+        """
+        data = self._client._request("DELETE", f"/v1/audiences/{audience_id}")
+        return DeletedResource.model_validate(data)
 
     def append_contacts(
         self,

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/resources/chats.py

@@ -1,9 +1,22 @@
 from __future__ import annotations
 
+from collections.abc import Sequence  # avoids shadowing by `ChatsResource.list`
 from typing import Any
 
 from blueticks._base_resource import BaseResource
-from blueticks.types.chats import Chat, ChatMedia, ChatMessage, MessageType, Participant
+from blueticks.types.chats import (
+    BatchMessageAcksResponse,
+    Chat,
+    ChatMedia,
+    ChatMessage,
+    ChatRef,
+    LoadOlderMessagesResponse,
+    MediaUrlResponse,
+    MessageAck,
+    MessageType,
+    OkResponse,
+    Participant,
+)
 from blueticks.types.page import Page
 
 
@@ -49,13 +62,15 @@ class ChatsResource(BaseResource):
         )
         return Page[Participant].model_validate(data)
 
-    def mark_read(self, chat_id: str) -> dict[str, Any]:
+    def mark_read(self, chat_id: str) -> OkResponse:
         """Mark a chat as read (sends read receipts if enabled)."""
-        return self._client._request("POST", f"/v1/chats/{chat_id}/mark_read")  # type: ignore[no-any-return]
+        data = self._client._request("POST", f"/v1/chats/{chat_id}/mark_read")
+        return OkResponse.model_validate(data)
 
-    def open(self, chat_id: str) -> dict[str, Any]:
+    def open(self, chat_id: str) -> ChatRef:
         """Open a chat on the engine (useful for UI-assisted workflows)."""
-        return self._client._request("POST", f"/v1/chats/{chat_id}/open")  # type: ignore[no-any-return]
+        data = self._client._request("POST", f"/v1/chats/{chat_id}/open")
+        return ChatRef.model_validate(data)
 
     def list_messages(
         self,
@@ -99,35 +114,43 @@ class ChatsResource(BaseResource):
         data = self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}")
         return ChatMessage.model_validate(data)
 
-    def get_message_ack(self, chat_id: str, key: str) -> dict[str, Any]:
+    def get_message_ack(self, chat_id: str, key: str) -> MessageAck:
         """Fetch ACK state for a single message."""
-        return self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}/ack")  # type: ignore[no-any-return]
+        data = self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}/ack")
+        return MessageAck.model_validate(data)
 
-    def react(self, chat_id: str, key: str, *, emoji: str) -> dict[str, Any]:
-        """Add or clear an emoji reaction on a message."""
-        return self._client._request(  # type: ignore[no-any-return]
+    def react(self, chat_id: str, key: str, *, emoji: str) -> OkResponse:
+        """Add or clear an emoji reaction on a message.
+
+        Pass an empty string for ``emoji`` to clear an existing reaction.
+        """
+        data = self._client._request(
             "POST",
             f"/v1/chats/{chat_id}/messages/{key}/reactions",
             body={"emoji": emoji},
         )
+        return OkResponse.model_validate(data)
 
-    def load_older_messages(self, chat_id: str) -> dict[str, Any]:
+    def load_older_messages(self, chat_id: str) -> LoadOlderMessagesResponse:
         """Pull older messages from the phone into the engine's local store."""
-        return self._client._request("POST", f"/v1/chats/{chat_id}/messages/load_older")  # type: ignore[no-any-return]
+        data = self._client._request("POST", f"/v1/chats/{chat_id}/messages/load_older")
+        return LoadOlderMessagesResponse.model_validate(data)
 
     def get_media(self, chat_id: str, key: str) -> ChatMedia:
         """Download message media (may be returned as base64)."""
         data = self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}/media")
         return ChatMedia.model_validate(data)
 
-    def get_media_url(self, chat_id: str, key: str) -> dict[str, Any]:
+    def get_media_url(self, chat_id: str, key: str) -> MediaUrlResponse:
         """Get a short-lived URL for message media, if available."""
-        return self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}/media_url")  # type: ignore[no-any-return]
+        data = self._client._request("GET", f"/v1/chats/{chat_id}/messages/{key}/media_url")
+        return MediaUrlResponse.model_validate(data)
 
-    def batch_message_acks(self, *, message_keys: list[str]) -> dict[str, Any]:  # type: ignore[valid-type]
+    def batch_message_acks(self, *, message_keys: Sequence[str]) -> BatchMessageAcksResponse:
         """Batch-fetch ACK data for up to 200 message keys at once."""
-        return self._client._request(  # type: ignore[no-any-return]
+        data = self._client._request(
             "POST",
             "/v1/chats/message_acks",
             body={"message_keys": message_keys},
         )
+        return BatchMessageAcksResponse.model_validate(data)

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/resources/groups.py

@@ -25,32 +25,37 @@ class GroupsResource(BaseResource):
         *,
         name: str | None = None,
         settings: dict[str, bool] | None = None,
-    ) -> dict[str, Any]:
+    ) -> Group:
         """Rename the group and/or update admin-only settings."""
         body: dict[str, Any] = {}
         if name is not None:
             body["name"] = name
         if settings is not None:
             body["settings"] = settings
-        return self._client._request("PATCH", f"/v1/groups/{group_id}", body=body)  # type: ignore[no-any-return]
+        data = self._client._request("PATCH", f"/v1/groups/{group_id}", body=body)
+        return Group.model_validate(data)
 
-    def add_member(self, group_id: str, *, chat_id: str) -> dict[str, Any]:
+    def add_member(self, group_id: str, *, chat_id: str) -> Group:
         """Invite a contact to the group."""
-        return self._client._request(  # type: ignore[no-any-return]
+        data = self._client._request(
             "POST", f"/v1/groups/{group_id}/members", body={"chat_id": chat_id}
         )
+        return Group.model_validate(data)
 
-    def remove_member(self, group_id: str, chat_id: str) -> dict[str, Any]:
+    def remove_member(self, group_id: str, chat_id: str) -> Group:
         """Remove a participant from the group."""
-        return self._client._request("DELETE", f"/v1/groups/{group_id}/members/{chat_id}")  # type: ignore[no-any-return]
+        data = self._client._request("DELETE", f"/v1/groups/{group_id}/members/{chat_id}")
+        return Group.model_validate(data)
 
-    def promote_admin(self, group_id: str, chat_id: str) -> dict[str, Any]:
+    def promote_admin(self, group_id: str, chat_id: str) -> Group:
         """Grant admin rights to a participant."""
-        return self._client._request("POST", f"/v1/groups/{group_id}/members/{chat_id}/admin")  # type: ignore[no-any-return]
+        data = self._client._request("POST", f"/v1/groups/{group_id}/members/{chat_id}/admin")
+        return Group.model_validate(data)
 
-    def demote_admin(self, group_id: str, chat_id: str) -> dict[str, Any]:
+    def demote_admin(self, group_id: str, chat_id: str) -> Group:
         """Revoke admin rights from a participant."""
-        return self._client._request("DELETE", f"/v1/groups/{group_id}/members/{chat_id}/admin")  # type: ignore[no-any-return]
+        data = self._client._request("DELETE", f"/v1/groups/{group_id}/members/{chat_id}/admin")
+        return Group.model_validate(data)
 
     def set_picture(
         self,
@@ -59,15 +64,17 @@ class GroupsResource(BaseResource):
         file_data_url: str,
         file_name: str | None = None,
         file_mime_type: str | None = None,
-    ) -> dict[str, Any]:
+    ) -> Group:
         """Upload a new group avatar (base64 data URL)."""
         body: dict[str, Any] = {"file_data_url": file_data_url}
         if file_name is not None:
             body["file_name"] = file_name
         if file_mime_type is not None:
             body["file_mime_type"] = file_mime_type
-        return self._client._request("PUT", f"/v1/groups/{group_id}/picture", body=body)  # type: ignore[no-any-return]
+        data = self._client._request("PUT", f"/v1/groups/{group_id}/picture", body=body)
+        return Group.model_validate(data)
 
-    def leave(self, group_id: str) -> dict[str, Any]:
-        """Leave the group (as the authenticated user)."""
-        return self._client._request("DELETE", f"/v1/groups/{group_id}/members/me")  # type: ignore[no-any-return]
+    def leave(self, group_id: str) -> None:
+        """Leave the group (as the authenticated user). Returns 204 No Content."""
+        self._client._request("DELETE", f"/v1/groups/{group_id}/members/me")
+        return None

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/resources/scheduled_messages.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from typing import Any
 
 from blueticks._base_resource import BaseResource
+from blueticks.types._deleted_resource import DeletedResource
 from blueticks.types.page import Page
 from blueticks.types.scheduled_messages import ScheduledMessage
 
@@ -61,10 +62,12 @@ class ScheduledMessagesResource(BaseResource):
         )
         return ScheduledMessage.model_validate(data)
 
-    def delete(self, scheduled_message_id: str) -> None:
+    def delete(self, scheduled_message_id: str) -> DeletedResource:
         """Cancel scheduled message.
 
-        Removes the resource with id.
+        Cancel a queued scheduled message before it fires. Soft-deletes the row
+        (still queryable in audit logs). Returns the deleted ref. Requires
+        ``messages:write``.
         """
-        self._client._request("DELETE", f"/v1/scheduled-messages/{scheduled_message_id}")
-        return None
+        data = self._client._request("DELETE", f"/v1/scheduled-messages/{scheduled_message_id}")
+        return DeletedResource.model_validate(data)

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/resources/webhooks.py

@@ -4,6 +4,7 @@ import builtins
 from typing import Any
 
 from blueticks._base_resource import BaseResource
+from blueticks.types._deleted_resource import DeletedResource
 from blueticks.types.page import Page
 from blueticks.types.webhooks import Webhook, WebhookCreateResult
 
@@ -66,9 +67,14 @@ class WebhooksResource(BaseResource):
         data = self._client._request("PATCH", f"/v1/webhooks/{webhook_id}", body=body)
         return Webhook.model_validate(data)
 
-    def delete(self, webhook_id: str) -> None:
-        self._client._request("DELETE", f"/v1/webhooks/{webhook_id}")
-        return None
+    def delete(self, webhook_id: str) -> DeletedResource:
+        """Delete webhook.
+
+        Delete a webhook subscription. Returns the deleted ref. Requires
+        ``webhooks:write``.
+        """
+        data = self._client._request("DELETE", f"/v1/webhooks/{webhook_id}")
+        return DeletedResource.model_validate(data)
 
     def rotate_secret(self, webhook_id: str) -> WebhookCreateResult:
         data = self._client._request("POST", f"/v1/webhooks/{webhook_id}/rotate-secret")

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/types/__init__.py

@@ -1,6 +1,20 @@
+from blueticks.types._deleted_resource import DeletedResource
 from blueticks.types.account import Account
 from blueticks.types.audiences import AppendContactsResult, Audience, Contact
 from blueticks.types.campaigns import Campaign
+from blueticks.types.chats import (
+    BatchMessageAckEntry,
+    BatchMessageAcksResponse,
+    Chat,
+    ChatMedia,
+    ChatMessage,
+    ChatRef,
+    LoadOlderMessagesResponse,
+    MediaUrlResponse,
+    MessageAck,
+    OkResponse,
+    Participant,
+)
 from blueticks.types.groups import Group, GroupParticipant
 from blueticks.types.messages import Message
 from blueticks.types.page import Page
@@ -12,12 +26,24 @@ __all__ = [
     "Account",
     "AppendContactsResult",
     "Audience",
+    "BatchMessageAckEntry",
+    "BatchMessageAcksResponse",
     "Campaign",
+    "Chat",
+    "ChatMedia",
+    "ChatMessage",
+    "ChatRef",
     "Contact",
+    "DeletedResource",
     "Group",
     "GroupParticipant",
+    "LoadOlderMessagesResponse",
+    "MediaUrlResponse",
     "Message",
+    "MessageAck",
+    "OkResponse",
     "Page",
+    "Participant",
     "Ping",
     "ScheduledMessage",
     "Webhook",

blueticks-3.3.2/src/blueticks/types/_deleted_resource.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict
+
+
+class DeletedResource(BaseModel):
+    """Response envelope returned by DELETE endpoints.
+
+    Returned by:
+    - DELETE /v1/audiences/{id}
+    - DELETE /v1/scheduled-messages/{id}
+    - DELETE /v1/webhooks/{id}
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    id: str
+    deleted: Literal[True]

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks/types/chats.py

@@ -106,3 +106,70 @@ class ChatMedia(BaseModel):
             "/ location / vcard."
         ),
     )
+
+
+class OkResponse(BaseModel):
+    """Generic ok envelope returned by mark_read and react endpoints."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    ok: Literal[True]
+
+
+class ChatRef(BaseModel):
+    """Response from POST /v1/chats/{chat_id}/open."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    chat_id: str
+
+
+class MessageAck(BaseModel):
+    """Response from GET /v1/chats/{chat_id}/messages/{key}/ack.
+
+    `ack` codes: -1=error, 0=pending, 1=server, 2=device, 3=read, 4=played;
+    None when no engine response.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    ack: Optional[int] = None  # noqa: UP045
+
+
+class LoadOlderMessagesResponse(BaseModel):
+    """Response from POST /v1/chats/{chat_id}/messages/load_older."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    total_messages: Optional[int] = None  # noqa: UP045
+    added: Optional[int] = None  # noqa: UP045
+    can_load_more: bool
+
+
+class MediaUrlResponse(BaseModel):
+    """Response from GET /v1/chats/{chat_id}/messages/{key}/media_url."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    url: Optional[str] = None  # noqa: UP045
+
+
+class BatchMessageAckEntry(BaseModel):
+    """One entry in :class:`BatchMessageAcksResponse.data`.
+
+    `ack` codes: -1=error, 0=pending, 1=server, 2=device, 3=read, 4=played;
+    `None` when the engine has not yet returned a status for this key.
+    """
+
+    model_config = ConfigDict(extra="ignore")
+
+    key: str
+    ack: Optional[int] = None  # noqa: UP045
+
+
+class BatchMessageAcksResponse(BaseModel):
+    """Response from POST /v1/chats/message_acks."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    data: list[BatchMessageAckEntry]

{blueticks-3.3.0 → blueticks-3.3.2/src/blueticks.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: blueticks
-Version: 3.3.0
+Version: 3.3.2
 Summary: Official Python client for the Blueticks API.
 Author-email: Blueticks <support@blueticks.co>
 License: MIT License

{blueticks-3.3.0 → blueticks-3.3.2}/src/blueticks.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/blueticks/resources/scheduled_messages.py
 src/blueticks/resources/utils.py
 src/blueticks/resources/webhooks.py
 src/blueticks/types/__init__.py
+src/blueticks/types/_deleted_resource.py
 src/blueticks/types/account.py
 src/blueticks/types/audiences.py
 src/blueticks/types/campaigns.py
@@ -44,8 +45,10 @@ src/blueticks/types/webhooks.py
 tests/test_account.py
 tests/test_audiences.py
 tests/test_campaigns.py
+tests/test_chats.py
 tests/test_client.py
 tests/test_errors.py
+tests/test_groups.py
 tests/test_messages.py
 tests/test_ping.py
 tests/test_scheduled_messages.py

{blueticks-3.3.0 → blueticks-3.3.2}/tests/test_audiences.py

@@ -99,10 +99,12 @@ def test_delete_audience():
     def handler(req: httpx.Request) -> httpx.Response:
         assert req.method == "DELETE"
         assert req.url.path == "/v1/audiences/aud_1"
-        return httpx.Response(204)
+        return httpx.Response(200, json={"id": "aud_1", "deleted": True})
 
     client = Blueticks(api_key="bt_live_test", _http_transport=httpx.MockTransport(handler))
-    assert client.audiences.delete("aud_1") is None
+    result = client.audiences.delete("aud_1")
+    assert result.id == "aud_1"
+    assert result.deleted is True
 
 
 def test_append_contacts():

blueticks-3.3.2/tests/test_chats.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from blueticks import Blueticks
+from blueticks._errors import AuthenticationError
+from blueticks.types.chats import (
+    BatchMessageAcksResponse,
+    Chat,
+    ChatMedia,
+    ChatMessage,
+    ChatRef,
+    LoadOlderMessagesResponse,
+    MediaUrlResponse,
+    MessageAck,
+    OkResponse,
+    Participant,
+)
+
+
+def _client(handler):
+    return Blueticks(api_key="bt_live_test", _http_transport=httpx.MockTransport(handler))
+
+
+def _chat(cid: str = "chat_1", **overrides) -> dict:
+    data = {
+        "id": cid,
+        "name": "Acme",
+        "is_group": False,
+        "last_message_at": "2026-04-23T00:00:00Z",
+        "unread_count": 3,
+    }
+    data.update(overrides)
+    return data
+
+
+def _chat_message(**overrides) -> dict:
+    data = {
+        "key": "msg_key_1",
+        "chat_id": "chat_1",
+        "from": "+15551234567",
+        "timestamp": "2026-04-23T00:00:00Z",
+        "text": "hello",
+        "type": "chat",
+        "from_me": False,
+        "ack": 3,
+        "media_url": None,
+        "caption": None,
+        "filename": None,
+    }
+    data.update(overrides)
+    return data
+
+
+def test_list_chats_returns_page_of_chats():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "GET"
+        assert req.url.path == "/v1/chats"
+        return httpx.Response(
+            200,
+            json={
+                "data": [_chat("chat_1"), _chat("chat_2")],
+                "has_more": False,
+                "next_cursor": None,
+            },
+        )
+
+    page = _client(handler).chats.list(query="acme", limit=10)
+    assert len(page.data) == 2
+    assert isinstance(page.data[0], Chat)
+    assert page.data[0].id == "chat_1"
+
+
+def test_get_chat_returns_typed_model():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1"
+        return httpx.Response(200, json=_chat("chat_1"))
+
+    chat = _client(handler).chats.get("chat_1")
+    assert isinstance(chat, Chat)
+    assert chat.unread_count == 3
+
+
+def test_list_participants_returns_page():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/participants"
+        return httpx.Response(
+            200,
+            json={
+                "data": [{"chat_id": "12345@c.us", "is_admin": True, "is_super_admin": False}],
+                "has_more": False,
+                "next_cursor": None,
+            },
+        )
+
+    page = _client(handler).chats.list_participants("chat_1")
+    assert isinstance(page.data[0], Participant)
+    assert page.data[0].is_admin is True
+
+
+def test_mark_read_returns_ok_response():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "POST"
+        assert req.url.path == "/v1/chats/chat_1/mark_read"
+        return httpx.Response(200, json={"ok": True})
+
+    result = _client(handler).chats.mark_read("chat_1")
+    assert isinstance(result, OkResponse)
+    assert result.ok is True
+
+
+def test_open_returns_chat_ref():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/open"
+        return httpx.Response(200, json={"chat_id": "chat_1"})
+
+    result = _client(handler).chats.open("chat_1")
+    assert isinstance(result, ChatRef)
+    assert result.chat_id == "chat_1"
+
+
+def test_list_messages_returns_page_of_chat_messages():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/messages"
+        assert req.url.params.get("mode") == "history"
+        assert req.url.params.get("message_types") == "image,video"
+        return httpx.Response(
+            200,
+            json={"data": [_chat_message()], "has_more": True, "next_cursor": "cur_2"},
+        )
+
+    page = _client(handler).chats.list_messages(
+        "chat_1", mode="history", message_types=["image", "video"]
+    )
+    assert isinstance(page.data[0], ChatMessage)
+    assert page.data[0].from_ == "+15551234567"
+    assert page.next_cursor == "cur_2"
+
+
+def test_get_message_returns_chat_message():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/messages/msg_key_1"
+        return httpx.Response(200, json=_chat_message())
+
+    msg = _client(handler).chats.get_message("chat_1", "msg_key_1")
+    assert isinstance(msg, ChatMessage)
+    assert msg.text == "hello"
+
+
+def test_get_message_ack_returns_typed_model():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/messages/msg_key_1/ack"
+        return httpx.Response(200, json={"ack": 3})
+
+    result = _client(handler).chats.get_message_ack("chat_1", "msg_key_1")
+    assert isinstance(result, MessageAck)
+    assert result.ack == 3
+
+
+def test_react_returns_ok_response():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.url.path == "/v1/chats/chat_1/messages/msg_key_1/reactions"
+        return httpx.Response(200, json={"ok": True})
+
+    result = _client(handler).chats.react("chat_1", "msg_key_1", emoji="🔥")
+    assert isinstance(result, OkResponse)
+    assert body_seen == {"emoji": "🔥"}
+
+
+def test_load_older_messages_returns_typed_model():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "POST"
+        assert req.url.path == "/v1/chats/chat_1/messages/load_older"
+        return httpx.Response(200, json={"total_messages": 124, "added": 24, "can_load_more": True})
+
+    result = _client(handler).chats.load_older_messages("chat_1")
+    assert isinstance(result, LoadOlderMessagesResponse)
+    assert result.added == 24
+    assert result.can_load_more is True
+
+
+def test_get_media_returns_chat_media():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/messages/msg_key_1/media"
+        return httpx.Response(
+            200,
+            json={
+                "url": "https://cdn.example/x.jpg",
+                "mimetype": "image/jpeg",
+                "filename": "x.jpg",
+                "data_base64": None,
+                "original_quality": True,
+                "media_unavailable": None,
+            },
+        )
+
+    result = _client(handler).chats.get_media("chat_1", "msg_key_1")
+    assert isinstance(result, ChatMedia)
+    assert result.mimetype == "image/jpeg"
+
+
+def test_get_media_url_returns_typed_model():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/chats/chat_1/messages/msg_key_1/media_url"
+        return httpx.Response(200, json={"url": "https://cdn.example/y.jpg"})
+
+    result = _client(handler).chats.get_media_url("chat_1", "msg_key_1")
+    assert isinstance(result, MediaUrlResponse)
+    assert result.url == "https://cdn.example/y.jpg"
+
+
+def test_batch_message_acks_returns_typed_model():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.method == "POST"
+        assert req.url.path == "/v1/chats/message_acks"
+        return httpx.Response(
+            200,
+            json={
+                "data": [
+                    {"key": "msg_a", "ack": 3},
+                    {"key": "msg_b", "ack": 1},
+                    {"key": "msg_c", "ack": None},
+                ]
+            },
+        )
+
+    result = _client(handler).chats.batch_message_acks(message_keys=["msg_a", "msg_b", "msg_c"])
+    assert isinstance(result, BatchMessageAcksResponse)
+    assert body_seen == {"message_keys": ["msg_a", "msg_b", "msg_c"]}
+    assert result.data[0].key == "msg_a"
+    assert result.data[0].ack == 3
+    assert result.data[1].ack == 1
+    assert result.data[2].ack is None
+
+
+def test_chats_get_raises_authentication_error_on_401():
+    def handler(req: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            401,
+            json={
+                "error": {
+                    "code": "authentication_required",
+                    "message": "bad key",
+                    "request_id": "req_chats_1",
+                }
+            },
+        )
+
+    with pytest.raises(AuthenticationError) as exc_info:
+        _client(handler).chats.get("chat_1")
+    assert exc_info.value.code == "authentication_required"
+    assert exc_info.value.request_id == "req_chats_1"
+
+
+def test_chat_validation_fails_when_required_field_missing():
+    def handler(req: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={})
+
+    with pytest.raises(ValidationError):
+        _client(handler).chats.get("chat_1")

blueticks-3.3.2/tests/test_groups.py

@@ -0,0 +1,175 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+from pydantic import ValidationError
+
+from blueticks import Blueticks
+from blueticks._errors import AuthenticationError
+from blueticks.types.groups import Group
+
+
+def _client(handler):
+    return Blueticks(api_key="bt_live_test", _http_transport=httpx.MockTransport(handler))
+
+
+def _group(gid: str = "grp_1", **overrides) -> dict:
+    data = {
+        "id": gid,
+        "name": "Acme Team",
+        "description": "Internal coordination",
+        "owner": "12345@c.us",
+        "created_at": "2026-04-23T00:00:00Z",
+        "last_message_at": "2026-04-24T00:00:00Z",
+        "participant_count": 5,
+        "announce": False,
+        "restrict": False,
+        "participants": None,
+    }
+    data.update(overrides)
+    return data
+
+
+def test_create_group_returns_typed_group():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.method == "POST"
+        assert req.url.path == "/v1/groups"
+        return httpx.Response(200, json=_group("grp_new"))
+
+    g = _client(handler).groups.create(name="Acme Team", participants=["12345@c.us"])
+    assert isinstance(g, Group)
+    assert body_seen == {"name": "Acme Team", "participants": ["12345@c.us"]}
+    assert g.id == "grp_new"
+
+
+def test_get_group_returns_typed_group():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.url.path == "/v1/groups/grp_1"
+        return httpx.Response(200, json=_group("grp_1"))
+
+    g = _client(handler).groups.get("grp_1")
+    assert isinstance(g, Group)
+    assert g.participant_count == 5
+
+
+def test_update_group_returns_typed_group():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.method == "PATCH"
+        assert req.url.path == "/v1/groups/grp_1"
+        return httpx.Response(200, json=_group("grp_1", name="Renamed"))
+
+    g = _client(handler).groups.update("grp_1", name="Renamed", settings={"announce": True})
+    assert isinstance(g, Group)
+    assert g.name == "Renamed"
+    assert body_seen == {"name": "Renamed", "settings": {"announce": True}}
+
+
+def test_add_member_returns_typed_group():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.method == "POST"
+        assert req.url.path == "/v1/groups/grp_1/members"
+        return httpx.Response(200, json=_group("grp_1", participant_count=6))
+
+    g = _client(handler).groups.add_member("grp_1", chat_id="99999@c.us")
+    assert isinstance(g, Group)
+    assert g.participant_count == 6
+    assert body_seen == {"chat_id": "99999@c.us"}
+
+
+def test_remove_member_returns_typed_group():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "DELETE"
+        assert req.url.path == "/v1/groups/grp_1/members/99999@c.us"
+        return httpx.Response(200, json=_group("grp_1", participant_count=4))
+
+    g = _client(handler).groups.remove_member("grp_1", "99999@c.us")
+    assert isinstance(g, Group)
+    assert g.participant_count == 4
+
+
+def test_promote_admin_returns_typed_group():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "POST"
+        assert req.url.path == "/v1/groups/grp_1/members/99999@c.us/admin"
+        return httpx.Response(200, json=_group("grp_1"))
+
+    g = _client(handler).groups.promote_admin("grp_1", "99999@c.us")
+    assert isinstance(g, Group)
+
+
+def test_demote_admin_returns_typed_group():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "DELETE"
+        assert req.url.path == "/v1/groups/grp_1/members/99999@c.us/admin"
+        return httpx.Response(200, json=_group("grp_1"))
+
+    g = _client(handler).groups.demote_admin("grp_1", "99999@c.us")
+    assert isinstance(g, Group)
+
+
+def test_set_picture_returns_typed_group():
+    body_seen: dict = {}
+
+    def handler(req: httpx.Request) -> httpx.Response:
+        body_seen.update(json.loads(req.content))
+        assert req.method == "PUT"
+        assert req.url.path == "/v1/groups/grp_1/picture"
+        return httpx.Response(200, json=_group("grp_1"))
+
+    g = _client(handler).groups.set_picture(
+        "grp_1",
+        file_data_url="data:image/png;base64,iVBORw0KG...",
+        file_name="logo.png",
+        file_mime_type="image/png",
+    )
+    assert isinstance(g, Group)
+    assert body_seen["file_data_url"].startswith("data:image/png;base64")
+    assert body_seen["file_name"] == "logo.png"
+    assert body_seen["file_mime_type"] == "image/png"
+
+
+def test_leave_group_returns_none_on_204():
+    def handler(req: httpx.Request) -> httpx.Response:
+        assert req.method == "DELETE"
+        assert req.url.path == "/v1/groups/grp_1/members/me"
+        return httpx.Response(204)
+
+    assert _client(handler).groups.leave("grp_1") is None
+
+
+def test_groups_get_raises_authentication_error_on_401():
+    def handler(req: httpx.Request) -> httpx.Response:
+        return httpx.Response(
+            401,
+            json={
+                "error": {
+                    "code": "authentication_required",
+                    "message": "bad key",
+                    "request_id": "req_groups_1",
+                }
+            },
+        )
+
+    with pytest.raises(AuthenticationError) as exc_info:
+        _client(handler).groups.get("grp_1")
+    assert exc_info.value.code == "authentication_required"
+    assert exc_info.value.request_id == "req_groups_1"
+
+
+def test_group_validation_fails_when_required_field_missing():
+    def handler(req: httpx.Request) -> httpx.Response:
+        return httpx.Response(200, json={})
+
+    with pytest.raises(ValidationError):
+        _client(handler).groups.get("grp_1")

{blueticks-3.3.0 → blueticks-3.3.2}/tests/test_scheduled_messages.py

@@ -113,14 +113,20 @@ def test_update_scheduled_message(mock_client) -> None:
     assert body_seen == {"text": "updated", "send_at": "2026-07-01T09:00:00Z"}
 
 
-def test_delete_scheduled_message_returns_none(mock_client) -> None:
+def test_delete_scheduled_message_returns_typed_ref(mock_client) -> None:
     def handler(req: httpx.Request) -> httpx.Response:
         assert req.method == "DELETE"
         assert req.url.path == "/v1/scheduled-messages/sched_1"
-        return httpx.Response(204)
+        return httpx.Response(
+            200,
+            content=json.dumps({"id": "sched_1", "deleted": True}).encode(),
+            headers={"content-type": "application/json"},
+        )
 
     with mock_client(handler) as client:
-        assert client.scheduled_messages.delete("sched_1") is None
+        result = client.scheduled_messages.delete("sched_1")
+    assert result.id == "sched_1"
+    assert result.deleted is True
 
 
 def test_scheduled_messages_propagates_authentication_error(mock_client) -> None:

{blueticks-3.3.0 → blueticks-3.3.2}/tests/test_webhooks_resource.py

@@ -90,14 +90,16 @@ def test_update_webhook():
     assert body_seen == {"status": "disabled"}
 
 
-def test_delete_webhook_returns_none():
+def test_delete_webhook_returns_typed_ref():
     def handler(req: httpx.Request) -> httpx.Response:
         assert req.method == "DELETE"
         assert req.url.path == "/v1/webhooks/wh_1"
-        return httpx.Response(204)
+        return httpx.Response(200, json={"id": "wh_1", "deleted": True})
 
     client = Blueticks(api_key="bt_live_test", _http_transport=httpx.MockTransport(handler))
-    assert client.webhooks.delete("wh_1") is None
+    result = client.webhooks.delete("wh_1")
+    assert result.id == "wh_1"
+    assert result.deleted is True
 
 
 def test_rotate_secret_returns_new_secret():

blueticks-3.3.0/src/blueticks/_version.py

@@ -1 +0,0 @@
-__version__ = "3.3.0"