wsapi-client 0.1.0__py3-none-any.whl

wsapi_client/__init__.py

@@ -0,0 +1,12 @@
+from .client import WSApiClient
+from .sse.client import SSEClient, SSEConnectionState
+from .exceptions import ApiException
+from .http import ApiResponse
+
+__all__ = [
+    "WSApiClient",
+    "SSEClient",
+    "SSEConnectionState",
+    "ApiException",
+    "ApiResponse",
+]

wsapi_client/api/calls.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from ..http import WSApiHttp, ApiResponse
+from ..models.requests.calls.reject_call_request import RejectCallRequest
+
+
+class CallsClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    def reject(self, call_id: str, request: RejectCallRequest) -> None:
+        self._http.send_json("PUT", f"/calls/{call_id}/reject", model=None, json=request.model_dump(by_alias=True))
+        return None
+
+    def try_reject(self, call_id: str, request: RejectCallRequest) -> ApiResponse[None]:
+        return self._http.try_send_json("PUT", f"/calls/{call_id}/reject", model=None, json=request.model_dump(by_alias=True))

wsapi_client/api/chats.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.chats.chat_info import ChatInfo
+
+
+class ChatsClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    def list(self) -> list[ChatInfo]:
+        return self._http.send_json("GET", "/chats", model=list[ChatInfo])
+
+    def get(self, chat_id: str) -> ChatInfo:
+        return self._http.send_json("GET", f"/chats/{chat_id}", model=ChatInfo)
+
+    # Try
+    def try_list(self) -> ApiResponse[list[ChatInfo]]:
+        return self._http.try_send_json("GET", "/chats", model=list[ChatInfo])
+
+    def try_get(self, chat_id: str) -> ApiResponse[ChatInfo]:
+        return self._http.try_send_json("GET", f"/chats/{chat_id}", model=ChatInfo)

wsapi_client/api/contacts.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.contacts.contact_info import ContactInfo
+from ..models.entities.contacts.contact_picture import ContactPicture
+from ..models.entities.contacts.contact_business_profile import ContactBusinessProfile
+
+
+class ContactsClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    # Standard methods
+    def list(self) -> list[ContactInfo]:
+        return self._http.send_json("GET", "/contacts", model=list[ContactInfo])
+
+    def get(self, contact_id: str) -> ContactInfo:
+        return self._http.send_json("GET", f"/contacts/{contact_id}", model=ContactInfo)
+
+    def get_picture(self, contact_id: str) -> ContactPicture:
+        return self._http.send_json("GET", f"/contacts/{contact_id}/picture", model=ContactPicture)
+
+    def get_business_profile(self, contact_id: str) -> ContactBusinessProfile:
+        return self._http.send_json("GET", f"/contacts/{contact_id}/business", model=ContactBusinessProfile)
+
+    def create(self, payload: dict) -> None:
+        self._http.send_json("POST", "/contacts", model=dict, json=payload)
+
+    def update(self, contact_id: str, payload: dict) -> None:
+        self._http.send_json("PUT", f"/contacts/{contact_id}", model=dict, json=payload)
+
+    def subscribe_presence(self, contact_id: str) -> None:
+        self._http.send_json("POST", f"/contacts/{contact_id}/presence", model=dict, json={})
+
+    # Try methods
+    def try_list(self) -> ApiResponse[list[ContactInfo]]:
+        return self._http.try_send_json("GET", "/contacts", model=list[ContactInfo])
+
+    def try_get(self, contact_id: str) -> ApiResponse[ContactInfo]:
+        return self._http.try_send_json("GET", f"/contacts/{contact_id}", model=ContactInfo)
+
+    def try_get_picture(self, contact_id: str) -> ApiResponse[ContactPicture]:
+        return self._http.try_send_json("GET", f"/contacts/{contact_id}/picture", model=ContactPicture)
+
+    def try_get_business_profile(self, contact_id: str) -> ApiResponse[ContactBusinessProfile]:
+        return self._http.try_send_json("GET", f"/contacts/{contact_id}/business", model=ContactBusinessProfile)
+
+    def try_create(self, payload: dict) -> ApiResponse[object]:
+        return self._http.try_send_json("POST", "/contacts", model=dict, json=payload)
+
+    def try_update(self, contact_id: str, payload: dict) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"/contacts/{contact_id}", model=dict, json=payload)
+
+    def try_subscribe_presence(self, contact_id: str) -> ApiResponse[object]:
+        return self._http.try_send_json("POST", f"/contacts/{contact_id}/presence", model=dict, json={})

wsapi_client/api/groups.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.groups.group_info import GroupInfo
+
+
+class GroupsClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    def list(self) -> list[GroupInfo]:
+        return self._http.send_json("GET", "/groups", model=list[GroupInfo])
+
+    def get(self, group_id: str) -> GroupInfo:
+        return self._http.send_json("GET", f"/groups/{group_id}", model=GroupInfo)
+
+    def update_description(self, group_id: str, payload: dict) -> None:
+        self._http.send_json("PUT", f"/groups/{group_id}/description", model=dict, json=payload)
+
+    def update_name(self, group_id: str, payload: dict) -> None:
+        self._http.send_json("PUT", f"/groups/{group_id}/name", model=dict, json=payload)
+
+    def leave(self, group_id: str) -> None:
+        self._http.send_json("PUT", f"/groups/{group_id}/leave", model=dict)
+
+    # Try variants
+    def try_list(self) -> ApiResponse[list[GroupInfo]]:
+        return self._http.try_send_json("GET", "/groups", model=list[GroupInfo])
+
+    def try_get(self, group_id: str) -> ApiResponse[GroupInfo]:
+        return self._http.try_send_json("GET", f"/groups/{group_id}", model=GroupInfo)
+
+    def try_update_description(self, group_id: str, payload: dict) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"/groups/{group_id}/description", model=dict, json=payload)
+
+    def try_update_name(self, group_id: str, payload: dict) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"/groups/{group_id}/name", model=dict, json=payload)
+
+    def try_leave(self, group_id: str) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"/groups/{group_id}/leave", model=dict)

wsapi_client/api/instance.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from typing import Optional
+
+from pydantic import BaseModel, Field
+
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.instance.instance_settings import InstanceSettings
+
+
+class InstanceClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    # Standard methods (raise ApiException)
+    def get_settings(self) -> InstanceSettings:
+        return self._http.send_json("GET", "/instance/settings", model=InstanceSettings)
+
+    def update_settings(self, settings: InstanceSettings) -> None:
+        self._http.send_json("PUT", "/instance/settings", model=dict, json=settings.model_dump(by_alias=True))
+
+    def restart(self) -> None:
+        self._http.send_json("PUT", "/instance/restart", model=dict)
+
+    def update_api_key(self) -> str:
+        return self._http.send_json("PUT", "/instance/apikey", model=str)
+
+    # Try methods (no exceptions)
+    def try_get_settings(self) -> ApiResponse[InstanceSettings]:
+        return self._http.try_send_json("GET", "/instance/settings", model=InstanceSettings)
+
+    def try_update_settings(self, settings: InstanceSettings) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", "/instance/settings", model=dict, json=settings.model_dump(by_alias=True))
+
+    def try_restart(self) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", "/instance/restart", model=dict)
+
+    def try_update_api_key(self) -> ApiResponse[str]:
+        return self._http.try_send_json("PUT", "/instance/apikey", model=str)

wsapi_client/api/media.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+
+from ..http import WSApiHttp, ApiResponse
+from ..models.requests.media.media_download_request import MediaDownloadRequest
+
+
+class MediaClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    def download(self, req: MediaDownloadRequest) -> bytes:
+        return self._http.send_bytes("POST", "/media/download", json=req.model_dump(by_alias=True))
+
+    def try_download(self, req: MediaDownloadRequest) -> ApiResponse[bytes]:
+        return self._http.try_send_bytes("POST", "/media/download", json=req.model_dump(by_alias=True))

wsapi_client/api/messages.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+from typing import Optional
+
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.messages.message_created import MessageCreated
+from ..models.requests.messages import (
+    MessageSendTextRequest,
+    MessageSendImageRequest,
+    MessageSendVideoRequest,
+    MessageSendAudioRequest,
+    MessageSendVoiceRequest,
+    MessageSendStickerRequest,
+    MessageSendDocumentRequest,
+    MessageSendContactRequest,
+    MessageSendLocationRequest,
+    MessageSendLinkRequest,
+    MessageSendReactionRequest,
+    MessageMarkAsReadRequest,
+    MessageDeleteRequest,
+    MessageDeleteForMeRequest,
+    MessageStarRequest,
+)
+
+
+class MessagesClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    # Standard methods
+    def send_text(self, req: MessageSendTextRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/text", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_image(self, req: MessageSendImageRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/image", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_video(self, req: MessageSendVideoRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/video", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_audio(self, req: MessageSendAudioRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/audio", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_voice(self, req: MessageSendVoiceRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/voice", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_sticker(self, req: MessageSendStickerRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/sticker", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_document(self, req: MessageSendDocumentRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/document", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_contact(self, req: MessageSendContactRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/contact", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_location(self, req: MessageSendLocationRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/location", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_link(self, req: MessageSendLinkRequest) -> MessageCreated:
+        return self._http.send_json("POST", "messages/link", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def send_reaction(self, message_id: str, req: MessageSendReactionRequest) -> MessageCreated:
+        return self._http.send_json("POST", f"messages/{message_id}/reaction", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def edit_text(self, message_id: str, req: MessageSendTextRequest) -> MessageCreated:
+        return self._http.send_json("PUT", f"messages/{message_id}/text", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def mark_as_read(self, message_id: str, req: MessageMarkAsReadRequest) -> None:
+        self._http.send_json("PUT", f"messages/{message_id}/read", model=None, json=req.model_dump(by_alias=True))
+
+    def star(self, message_id: str, req: MessageStarRequest) -> None:
+        self._http.send_json("PUT", f"messages/{message_id}/star", model=None, json=req.model_dump(by_alias=True))
+
+    def delete(self, message_id: str, req: MessageDeleteRequest) -> None:
+        self._http.send_json("PUT", f"messages/{message_id}/delete", model=None, json=req.model_dump(by_alias=True))
+
+    def delete_for_me(self, message_id: str, req: MessageDeleteForMeRequest) -> None:
+        self._http.send_json("PUT", f"messages/{message_id}/delete/forme", model=None, json=req.model_dump(by_alias=True))
+
+    # Try variants
+    def try_send_text(self, req: MessageSendTextRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/text", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_image(self, req: MessageSendImageRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/image", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_video(self, req: MessageSendVideoRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/video", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_audio(self, req: MessageSendAudioRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/audio", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_voice(self, req: MessageSendVoiceRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/voice", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_sticker(self, req: MessageSendStickerRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/sticker", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_document(self, req: MessageSendDocumentRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/document", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_contact(self, req: MessageSendContactRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/contact", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_location(self, req: MessageSendLocationRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/location", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_link(self, req: MessageSendLinkRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", "messages/link", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_send_reaction(self, message_id: str, req: MessageSendReactionRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("POST", f"messages/{message_id}/reaction", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_edit_text(self, message_id: str, req: MessageSendTextRequest) -> ApiResponse[MessageCreated]:
+        return self._http.try_send_json("PUT", f"messages/{message_id}/text", model=MessageCreated, json=req.model_dump(by_alias=True))
+
+    def try_mark_as_read(self, message_id: str, req: MessageMarkAsReadRequest) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"messages/{message_id}/read", model=None, json=req.model_dump(by_alias=True))
+
+    def try_star(self, message_id: str, req: MessageStarRequest) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"messages/{message_id}/star", model=None, json=req.model_dump(by_alias=True))
+
+    def try_delete(self, message_id: str, req: MessageDeleteRequest) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"messages/{message_id}/delete", model=None, json=req.model_dump(by_alias=True))
+
+    def try_delete_for_me(self, message_id: str, req: MessageDeleteForMeRequest) -> ApiResponse[object]:
+        return self._http.try_send_json("PUT", f"messages/{message_id}/delete/forme", model=None, json=req.model_dump(by_alias=True))

wsapi_client/api/session.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+from ..http import WSApiHttp, ApiResponse
+from ..models.entities.session.session_status import SessionStatus
+from ..models.entities.session.session_pair_code import SessionPairCode
+
+
+class SessionClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    # Standard methods
+    def get_login_qr_image(self) -> bytes:
+        # C# returned byte[] via JSON helper, but Python will treat it as bytes if endpoint returns bytes.
+        # If API actually returns base64 JSON, we can add decoding later.
+        return self._http.send_bytes("GET", "/session/login/qr/image")
+
+    def get_login_qr_code(self) -> str:
+        return self._http.send_json("GET", "/session/login/qr/code", model=str)
+
+    def get_login_pair_code(self, phone_number: str) -> SessionPairCode:
+        return self._http.send_json("GET", f"/session/login/code/{phone_number}", model=SessionPairCode)
+
+    def logout(self) -> None:
+        self._http.send_json("POST", "/session/logout", model=dict)
+
+    def get_session_status(self) -> SessionStatus:
+        return self._http.send_json("GET", "/session/status", model=SessionStatus)
+
+    # Try methods
+    def try_get_login_qr_image(self) -> ApiResponse[bytes]:
+        return self._http.try_send_bytes("GET", "/session/login/qr/image")
+
+    def try_get_login_qr_code(self) -> ApiResponse[str]:
+        return self._http.try_send_json("GET", "/session/login/qr/code", model=str)
+
+    def try_get_login_pair_code(self, phone_number: str) -> ApiResponse[SessionPairCode]:
+        return self._http.try_send_json("GET", f"/session/login/code/{phone_number}", model=SessionPairCode)
+
+    def try_logout(self) -> ApiResponse[object]:
+        return self._http.try_send_json("POST", "/session/logout", model=dict)
+
+    def try_get_session_status(self) -> ApiResponse[SessionStatus]:
+        return self._http.try_send_json("GET", "/session/status", model=SessionStatus)

wsapi_client/api/users.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+from typing import Optional
+
+from ..http import WSApiHttp
+from ..models.entities.users.user_info import UserInfo
+
+
+class UsersClient:
+    def __init__(self, http: WSApiHttp) -> None:
+        self._http = http
+
+    def get_by_id(self, user_id: str) -> Optional[UserInfo]:
+        return self._http.send_json("GET", f"/users/{user_id}", model=UserInfo)
+
+    def try_get_by_id(self, user_id: str):
+        return self._http.try_send_json("GET", f"/users/{user_id}", model=UserInfo)

wsapi_client/client.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+from typing import Optional
+
+from .http import WSApiHttp
+from .api.instance import InstanceClient
+from .api.messages import MessagesClient
+from .api.media import MediaClient
+from .api.session import SessionClient
+from .api.contacts import ContactsClient
+from .api.groups import GroupsClient
+from .api.chats import ChatsClient
+from .api.users import UsersClient
+from .api.calls import CallsClient
+
+
+class WSApiClient:
+    def __init__(
+        self,
+        api_key: str,
+        instance_id: str,
+        *,
+        base_url: str = "https://api.wsapi.chat",
+        timeout: float = 30.0,
+    ) -> None:
+        self._http = WSApiHttp(api_key=api_key, instance_id=instance_id, base_url=base_url, timeout=timeout)
+
+        # Surface parity with .NET: expose sub-clients
+        self.instance = InstanceClient(self._http)
+        self.messages = MessagesClient(self._http)
+        self.media = MediaClient(self._http)
+        self.session = SessionClient(self._http)
+        self.contacts = ContactsClient(self._http)
+        self.groups = GroupsClient(self._http)
+        self.chats = ChatsClient(self._http)
+        self.users = UsersClient(self._http)
+        self.calls = CallsClient(self._http)
+
+    def close(self) -> None:
+        self._http.close()

wsapi_client/events/factory.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+from datetime import datetime
+from typing import Any, Dict, Type
+
+from pydantic import TypeAdapter
+
+from ..models.events.base_event import BaseEvent
+from ..models.events.messages.message_star_event import MessageStarEvent
+from ..models.events.messages.message_read_event import MessageReadEvent
+from ..models.events.messages.message_event import MessageEvent
+from ..models.events.messages.message_delete_event import MessageDeleteEvent
+from ..models.events.messages.message_history_sync_event import MessageHistorySyncEvent
+from ..models.events.contacts.contact_event import ContactEvent
+from ..models.events.users.user_push_name_event import UserPushNameEvent
+from ..models.events.users.user_picture_event import UserPictureEvent
+from ..models.events.users.user_presence_event import UserPresenceEvent
+from ..models.events.users.user_status_event import UserStatusEvent
+from ..models.events.calls.call_offer_event import CallOfferEvent
+from ..models.events.calls.call_accept_event import CallAcceptEvent
+from ..models.events.calls.call_terminate_event import CallTerminateEvent
+from ..models.events.chats.chat_presence_event import ChatPresenceEvent
+from ..models.events.chats.chat_setting_event import ChatSettingEvent
+from ..models.events.session.session_logged_in_event import SessionLoggedInEvent
+from ..models.events.session.session_logged_out_event import SessionLoggedOutEvent
+from ..models.events.session.session_logged_error_event import SessionLoggedErrorEvent
+
+
+_EVENT_TYPES: Dict[str, Type[Any]] = {
+    "logged_in": SessionLoggedInEvent,
+    "logged_out": SessionLoggedOutEvent,
+    "logged_error": SessionLoggedErrorEvent,
+    "chat_presence": ChatPresenceEvent,
+    "chat_setting": ChatSettingEvent,
+    "message": MessageEvent,
+    "message_delete": MessageDeleteEvent,
+    "message_history_sync": MessageHistorySyncEvent,
+    "message_read": MessageReadEvent,
+    "message_star": MessageStarEvent,
+    "contact": ContactEvent,
+    "user_push_name": UserPushNameEvent,
+    "user_picture": UserPictureEvent,
+    "user_presence": UserPresenceEvent,
+    "user_status": UserStatusEvent,
+    "call_offer": CallOfferEvent,
+    "call_accept": CallAcceptEvent,
+    "call_terminate": CallTerminateEvent,
+}
+
+
+def parse_event(raw_json: str) -> BaseEvent:
+    import json
+
+    if not raw_json:
+        raise ValueError("JSON cannot be empty")
+    obj = json.loads(raw_json)
+
+    # Validate base props
+    if "receivedAt" not in obj or "instanceId" not in obj or "eventType" not in obj or "eventData" not in obj:
+        raise ValueError("Missing required event fields")
+
+    event_type = obj["eventType"]
+    if event_type not in _EVENT_TYPES:
+        raise ValueError(f"Unknown event type: {event_type}")
+
+    model = _EVENT_TYPES[event_type]
+    data = obj["eventData"]
+
+    # Deserialize payload
+    payload = TypeAdapter(model).validate_python(data)
+
+    # Inject base props for convenience if payload doesn’t derive BaseEvent
+    base = BaseEvent.model_validate({
+        "instanceId": obj["instanceId"],
+        "receivedAt": obj["receivedAt"],
+        "eventType": event_type,
+    })
+
+    # Attach base info dynamically
+    # For now, return the payload; callers can use base separately if needed.
+    # Future: create a wrapper type with .base and .data
+    payload._base = base  # type: ignore[attr-defined]
+    return payload  # type: ignore[return-value]

wsapi_client/exceptions.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+from typing import Optional
+
+from .models.problem_details import ProblemDetails
+
+
+class ApiException(Exception):
+    def __init__(self, problem: ProblemDetails):
+        super().__init__(problem.detail or problem.title or "API error")
+        self.problem: ProblemDetails = problem
+
+    def __repr__(self) -> str:
+        return f"ApiException(status={self.problem.status}, title={self.problem.title!r})"

wsapi_client/http.py

@@ -0,0 +1,123 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Generic, Optional, Type, TypeVar, cast
+
+import httpx
+from pydantic import BaseModel, ValidationError, TypeAdapter
+
+from .exceptions import ApiException
+from .models.problem_details import ProblemDetails
+
+T = TypeVar("T")
+
+
+@dataclass
+class ApiResponse(Generic[T]):
+    result: Optional[T] = None
+    error: Optional[ProblemDetails] = None
+
+    @property
+    def is_success(self) -> bool:
+        return self.error is None
+
+
+class WSApiHttp:
+    def __init__(
+        self,
+        api_key: str,
+        instance_id: str,
+        base_url: str = "https://api.wsapi.chat",
+        timeout: float = 30.0,
+        client: Optional[httpx.Client] = None,
+    ) -> None:
+        headers = {
+            "X-Api-Key": api_key,
+            "X-Instance-Id": instance_id,
+        }
+        self._client = client or httpx.Client(base_url=base_url, headers=headers, timeout=timeout)
+
+    def close(self) -> None:
+        self._client.close()
+
+    # --- core request helpers ---
+    def _handle_error(self, resp: httpx.Response) -> None:
+        # Try to parse ProblemDetails
+        problem: Optional[ProblemDetails] = None
+        try:
+            data = resp.json()
+            problem = ProblemDetails.model_validate(data)
+        except Exception:
+            # non-JSON body
+            problem = ProblemDetails(status=resp.status_code, detail=resp.text)
+        raise ApiException(problem)
+
+    def _handle_exception_to_api_response(self, exc: Exception) -> ProblemDetails:
+        # Map timeouts to 408, others to 500-like behavior
+        if isinstance(exc, httpx.TimeoutException):
+            return ProblemDetails(status=408, title="Request Timeout", detail="The request timed out")
+        if isinstance(exc, httpx.TransportError):
+            return ProblemDetails(status=500, title="Request Failed", detail=str(exc))
+        return ProblemDetails(status=500, title="Request Failed", detail=str(exc))
+
+    def _parse_json(self, data: Any, model: Type[T] | Any) -> T:
+        if isinstance(model, type) and issubclass(model, BaseModel):
+            return cast(T, model.model_validate(data))
+        adapter = TypeAdapter(model)  # type: ignore[arg-type]
+        return adapter.validate_python(data)  # type: ignore[return-value]
+
+    def _has_body(self, resp: httpx.Response) -> bool:
+        if resp.status_code == 204:
+            return False
+        # Some servers return 200 with empty body; if content attr is missing (mock), assume body exists
+        if hasattr(resp, "content"):
+            return resp.content is not None and len(resp.content) > 0
+        return True
+
+    # JSON response
+    def send_json(self, method: str, url: str, *, model: Type[T] | Any | None, json: Any | None = None) -> Optional[T]:
+        resp = self._client.request(method, url, json=json)
+        if 200 <= resp.status_code < 300:
+            if model is None or not self._has_body(resp):
+                return None
+            data = resp.json()
+            return self._parse_json(data, model)
+        self._handle_error(resp)
+        raise AssertionError("Unreachable")
+
+    def try_send_json(self, method: str, url: str, *, model: Type[T] | Any | None, json: Any | None = None) -> ApiResponse[Optional[T]]:
+        try:
+            resp = self._client.request(method, url, json=json)
+            if 200 <= resp.status_code < 300:
+                if model is None or not self._has_body(resp):
+                    return ApiResponse(result=None)
+                data = resp.json()
+                return ApiResponse(result=self._parse_json(data, model))
+            # !2xx -> map to ProblemDetails
+            try:
+                problem = ProblemDetails.model_validate(resp.json())
+            except Exception:
+                problem = ProblemDetails(status=resp.status_code, detail=resp.text)
+            return ApiResponse(error=problem)
+        except Exception as exc:
+            return ApiResponse(error=self._handle_exception_to_api_response(exc))
+
+    # Bytes response
+    def send_bytes(self, method: str, url: str, *, json: Any | None = None) -> bytes:
+        resp = self._client.request(method, url, json=json)
+        if 200 <= resp.status_code < 300:
+            return resp.content
+        self._handle_error(resp)
+        raise AssertionError("Unreachable")
+
+    def try_send_bytes(self, method: str, url: str, *, json: Any | None = None) -> ApiResponse[bytes]:
+        try:
+            resp = self._client.request(method, url, json=json)
+            if 200 <= resp.status_code < 300:
+                return ApiResponse(result=resp.content)
+            try:
+                problem = ProblemDetails.model_validate(resp.json())
+            except Exception:
+                problem = ProblemDetails(status=resp.status_code, detail=resp.text)
+            return ApiResponse(error=problem)
+        except Exception as exc:
+            return ApiResponse(error=self._handle_exception_to_api_response(exc))

wsapi_client/models/entities/chats/chat_archive.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class ChatArchive(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+
+    is_archived: bool = Field(alias="isArchived")