maxapi-python 0.1.1__py3-none-any.whl → 0.1.2__py3-none-any.whl

pymax/static.py

@@ -0,0 +1,210 @@
+from enum import Enum, IntEnum
+
+
+class Opcode(IntEnum):
+    PING = 1
+    DEBUG = 2
+    RECONNECT = 3
+    LOG = 5
+    SESSION_INIT = 6
+    PROFILE = 16
+    AUTH_REQUEST = 17
+    AUTH = 18
+    LOGIN = 19
+    LOGOUT = 20
+    SYNC = 21
+    CONFIG = 22
+    AUTH_CONFIRM = 23
+    PRESET_AVATARS = 25
+    ASSETS_GET = 26
+    UNKNOWN_26 = 26
+    ASSETS_UPDATE = 27
+    ASSETS_GET_BY_IDS = 28
+    ASSETS_ADD = 29
+    SEARCH_FEEDBACK = 31
+    CONTACT_INFO = 32
+    CONTACT_ADD = 33
+    CONTACT_UPDATE = 34
+    CONTACT_PRESENCE = 35
+    CONTACT_LIST = 36
+    CONTACT_SEARCH = 37
+    CONTACT_MUTUAL = 38
+    CONTACT_PHOTOS = 39
+    CONTACT_SORT = 40
+    CONTACT_VERIFY = 42
+    REMOVE_CONTACT_PHOTO = 43
+    CONTACT_INFO_BY_PHONE = 46
+    CHAT_INFO = 48
+    CHAT_HISTORY = 49
+    CHAT_MARK = 50
+    CHAT_MEDIA = 51
+    CHAT_DELETE = 52
+    CHATS_LIST = 53
+    CHAT_CLEAR = 54
+    CHAT_UPDATE = 55
+    CHAT_CHECK_LINK = 56
+    CHAT_JOIN = 57
+    CHAT_LEAVE = 58
+    CHAT_MEMBERS = 59
+    PUBLIC_SEARCH = 60
+    CHAT_CLOSE = 61
+    CHAT_CREATE = 63
+    MSG_SEND = 64
+    MSG_TYPING = 65
+    MSG_DELETE = 66
+    MSG_EDIT = 67
+    CHAT_SEARCH = 68
+    MSG_SHARE_PREVIEW = 70
+    MSG_GET = 71
+    MSG_SEARCH_TOUCH = 72
+    MSG_SEARCH = 73
+    MSG_GET_STAT = 74
+    CHAT_SUBSCRIBE = 75
+    VIDEO_CHAT_START = 76
+    CHAT_MEMBERS_UPDATE = 77
+    VIDEO_CHAT_HISTORY = 79
+    PHOTO_UPLOAD = 80
+    STICKER_UPLOAD = 81
+    VIDEO_UPLOAD = 82
+    VIDEO_PLAY = 83
+    CHAT_PIN_SET_VISIBILITY = 86
+    FILE_UPLOAD = 87
+    FILE_DOWNLOAD = 88
+    LINK_INFO = 89
+    MSG_DELETE_RANGE = 92
+    SESSIONS_INFO = 96
+    SESSIONS_CLOSE = 97
+    PHONE_BIND_REQUEST = 98
+    PHONE_BIND_CONFIRM = 99
+    CONFIRM_PRESENT = 101
+    GET_INBOUND_CALLS = 103
+    EXTERNAL_CALLBACK = 105
+    AUTH_VALIDATE_PASSWORD = 107
+    AUTH_VALIDATE_HINT = 108
+    AUTH_VERIFY_EMAIL = 109
+    AUTH_CHECK_EMAIL = 110
+    AUTH_SET_2FA = 111
+    AUTH_CREATE_TRACK = 112
+    AUTH_LOGIN_CHECK_PASSWORD = 115
+    CHAT_COMPLAIN = 117
+    MSG_SEND_CALLBACK = 118
+    SUSPEND_BOT = 119
+    LOCATION_STOP = 124
+    LOCATION_SEND = 125
+    LOCATION_REQUEST = 126
+    GET_LAST_MENTIONS = 127
+    NOTIF_MESSAGE = 128
+    NOTIF_TYPING = 129
+    NOTIF_MARK = 130
+    NOTIF_CONTACT = 131
+    NOTIF_PRESENCE = 132
+    NOTIF_CONFIG = 134
+    NOTIF_CHAT = 135
+    NOTIF_ATTACH = 136
+    NOTIF_CALL_START = 137
+    NOTIF_CONTACT_SORT = 139
+    NOTIF_MSG_DELETE_RANGE = 140
+    NOTIF_MSG_DELETE = 142
+    NOTIF_CALLBACK_ANSWER = 143
+    CHAT_BOT_COMMANDS = 144
+    BOT_INFO = 145
+    NOTIF_LOCATION = 147
+    NOTIF_LOCATION_REQUEST = 148
+    NOTIF_ASSETS_UPDATE = 150
+    NOTIF_DRAFT = 152
+    NOTIF_DRAFT_DISCARD = 153
+    NOTIF_MSG_DELAYED = 154
+    NOTIF_MSG_REACTIONS_CHANGED = 155
+    NOTIF_MSG_YOU_REACTED = 156
+    CALLS_TOKEN = 158
+    NOTIF_PROFILE = 159
+    WEB_APP_INIT_DATA = 160
+    DRAFT_SAVE = 176
+    DRAFT_DISCARD = 177
+    MSG_REACTION = 178
+    MSG_CANCEL_REACTION = 179
+    MSG_GET_REACTIONS = 180
+    MSG_GET_DETAILED_REACTIONS = 181
+    STICKER_CREATE = 193
+    STICKER_SUGGEST = 194
+    VIDEO_CHAT_MEMBERS = 195
+    CHAT_HIDE = 196
+    CHAT_SEARCH_COMMON_PARTICIPANTS = 198
+    PROFILE_DELETE = 199
+    PROFILE_DELETE_TIME = 200
+    ASSETS_REMOVE = 259
+    ASSETS_MOVE = 260
+    ASSETS_LIST_MODIFY = 261
+    FOLDERS_GET = 272
+    FOLDERS_GET_BY_ID = 273
+    FOLDERS_UPDATE = 274
+    FOLDERS_REORDER = 275
+    FOLDERS_DELETE = 276
+    NOTIF_FOLDERS = 277
+
+
+class ChatType(str, Enum):
+    DIALOG = "DIALOG"
+    CHAT = "CHAT"
+    CHANNEL = "CHANNEL"
+
+
+class MessageType(str, Enum):
+    TEXT = "TEXT"
+    SYSTEM = "SYSTEM"
+    SERVICE = "SERVICE"
+
+
+class MessageStatus(str, Enum):
+    SENT = "SENT"
+    DELIVERED = "DELIVERED"
+    READ = "READ"
+    ERROR = "ERROR"
+
+
+class ElementType(str, Enum):
+    TEXT = "text"
+    MENTION = "mention"
+    LINK = "link"
+    EMOJI = "emoji"
+
+
+class AuthType(str, Enum):
+    START_AUTH = "START_AUTH"
+    CHECK_CODE = "CHECK_CODE"
+
+
+class AccessType(str, Enum):
+    PUBLIC = "PUBLIC"
+    PRIVATE = "PRIVATE"
+    SECRET = "SECRET"
+
+
+class DeviceType(str, Enum):
+    WEB = "WEB"
+    ANDROID = "ANDROID"
+    IOS = "IOS"
+
+
+class AttachType(str, Enum):
+    PHOTO = "PHOTO"
+    VIDEO = "VIDEO"
+    FILE = "FILE"
+    STICKER = "STICKER"
+
+
+class Constants(Enum):
+    PHONE_REGEX = r"^\+?\d{10,15}$"
+    WEBSOCKET_URI = "wss://ws-api.oneme.ru/websocket"
+    DEFAULT_TIMEOUT = 10.0
+    DEFAULT_USER_AGENT = {
+        "deviceType": "WEB",
+        "locale": "ru",
+        "deviceLocale": "ru",
+        "osVersion": "Linux",
+        "deviceName": "Chrome",
+        "headerUserAgent": "Mozilla/5.0 ...",
+        "appVersion": "25.8.5",
+        "screen": "1080x1920 1.0x",
+        "timezone": "Europe/Moscow",
+    }

pymax/types.py

@@ -0,0 +1,432 @@
+from typing import Any, override
+
+from .static import (
+    AccessType,
+    AttachType,
+    ChatType,
+    ElementType,
+    MessageStatus,
+    MessageType,
+)
+
+
+class Names:
+    def __init__(
+        self, name: str, first_name: str, last_name: str | None, type: str
+    ) -> None:
+        self.name = name
+        self.first_name = first_name
+        self.last_name = last_name
+        self.type = type
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Names":
+        return cls(
+            name=data["name"],
+            first_name=data["firstName"],
+            last_name=data.get("lastName"),
+            type=data["type"],
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return f"Names(name={self.name!r}, first_name={self.first_name!r}, last_name={self.last_name!r}, type={self.type!r})"
+
+    @override
+    def __str__(self) -> str:
+        return self.name
+
+
+class Me:
+    def __init__(
+        self,
+        id: int,
+        account_status: int,
+        phone: str,
+        names: list[Names],
+        update_time: int,
+        options: list[str] | None = None,
+    ) -> None:
+        self.id = id
+        self.account_status = account_status
+        self.phone = phone
+        self.update_time = update_time
+        self.options = options
+        self.names = names
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Me":
+        return cls(
+            id=data["id"],
+            account_status=data["accountStatus"],
+            phone=data["phone"],
+            names=[Names.from_dict(n) for n in data["names"]],
+            update_time=data["updateTime"],
+            options=data.get("options"),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return f"Me(id={self.id!r}, account_status={self.account_status!r}, phone={self.phone!r}, names={self.names!r}, update_time={self.update_time!r}, options={self.options!r})"
+
+    @override
+    def __str__(self) -> str:
+        return f"Me {self.id}: {', '.join(str(n) for n in self.names)}"
+
+
+class Element:
+    def __init__(
+        self, type: ElementType | str, length: int, from_: int | None = None
+    ) -> None:
+        self.type = type
+        self.length = length
+        self.from_ = from_
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Element":
+        return cls(type=data["type"], length=data["length"], from_=data.get("from"))
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"Element(type={self.type!r}, length={self.length!r}, from_={self.from_!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.type}({self.length})"
+
+
+class Message:
+    def __init__(
+        self,
+        sender: int | None,
+        elements: list[Element] | None,
+        reaction_info: dict[str, Any] | None,
+        options: int | None,
+        id: int,
+        time: int,
+        text: str,
+        status: MessageStatus | str | None,
+        type: MessageType | str,
+        attaches: list[Any],
+    ) -> None:
+        self.sender = sender
+        self.elements = elements
+        self.options = options
+        self.id = id
+        self.time = time
+        self.text = text
+        self.type = type
+        self.attaches = attaches
+        self.status = status
+        self.reactionInfo = reaction_info
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Message":
+        return cls(
+            sender=data.get("sender"),
+            elements=[Element.from_dict(e) for e in data.get("elements", [])],
+            options=data.get("options"),
+            id=data["id"],
+            time=data["time"],
+            text=data["text"],
+            type=data["type"],
+            attaches=data.get("attaches", []),
+            status=data.get("status"),
+            reaction_info=data.get("reactionInfo"),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"Message(id={self.id!r}, sender={self.sender!r}, text={self.text!r}, "
+            f"type={self.type!r}, status={self.status!r}, elements={self.elements!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"Message {self.id} from {self.sender}: {self.text}"
+
+
+class Dialog:
+    def __init__(
+        self,
+        cid: int | None,
+        owner: int,
+        has_bots: bool | None,
+        join_time: int,
+        created: int,
+        last_message: Message | None,
+        type: ChatType | str,
+        last_fire_delayed_error_time: int,
+        last_delayed_update_time: int,
+        prev_message_id: str | None,
+        options: dict[str, bool],
+        modified: int,
+        last_event_time: int,
+        id: int,
+        status: str,
+        participants: dict[str, int],
+    ) -> None:
+        self.cid = cid
+        self.owner = owner
+        self.has_bots = has_bots
+        self.join_time = join_time
+        self.created = created
+        self.last_message = last_message
+        self.type = type
+        self.last_fire_delayed_error_time = last_fire_delayed_error_time
+        self.last_delayed_update_time = last_delayed_update_time
+        self.prev_message_id = prev_message_id
+        self.options = options
+        self.modified = modified
+        self.last_event_time = last_event_time
+        self.id = id
+        self.status = status
+        self.participants = participants
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Dialog":
+        return cls(
+            cid=data.get("cid"),
+            owner=data["owner"],
+            has_bots=data.get("hasBots"),
+            join_time=data["joinTime"],
+            created=data["created"],
+            last_message=Message.from_dict(data["lastMessage"])
+            if data.get("lastMessage")
+            else None,
+            type=ChatType(data["type"]),
+            last_fire_delayed_error_time=data["lastFireDelayedErrorTime"],
+            last_delayed_update_time=data["lastDelayedUpdateTime"],
+            prev_message_id=data.get("prevMessageId"),
+            options=data.get("options", {}),
+            modified=data["modified"],
+            last_event_time=data["lastEventTime"],
+            id=data["id"],
+            status=data["status"],
+            participants=data["participants"],
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return f"Dialog(id={self.id!r}, owner={self.owner!r}, type={self.type!r}, last_message={self.last_message!r})"
+
+    @override
+    def __str__(self) -> str:
+        return f"Dialog {self.id} ({self.type})"
+
+
+class Chat:
+    def __init__(
+        self,
+        participants_count: int,
+        access: AccessType | str,
+        invited_by: int | None,
+        link: str | None,
+        chat_type: ChatType | str,
+        title: str | None,
+        last_fire_delayed_error_time: int,
+        last_delayed_update_time: int,
+        options: dict[str, bool],
+        base_raw_icon_url: str | None,
+        base_icon_url: str | None,
+        description: str | None,
+        modified: int,
+        id_: int,
+        admin_participants: dict[int, dict[Any, Any]],
+        participants: dict[int, int],
+        owner: int,
+        join_time: int,
+        created: int,
+        last_message: Message | None,
+        prev_message_id: str | None,
+        last_event_time: int,
+        messages_count: int,
+        admins: list[int],
+        restrictions: int | None,
+        status: str,
+        cid: int,
+    ) -> None:
+        self.participants_count = participants_count
+        self.access = access
+        self.invited_by = invited_by
+        self.link = link
+        self.type = chat_type
+        self.title = title
+        self.last_fire_delayed_error_time = last_fire_delayed_error_time
+        self.last_delayed_update_time = last_delayed_update_time
+        self.options = options
+        self.base_raw_icon_url = base_raw_icon_url
+        self.base_icon_url = base_icon_url
+        self.description = description
+        self.modified = modified
+        self.id = id_
+        self.admin_participants = admin_participants
+        self.participants = participants
+        self.owner = owner
+        self.join_time = join_time
+        self.created = created
+        self.last_message = last_message
+        self.prev_message_id = prev_message_id
+        self.last_event_time = last_event_time
+        self.messages_count = messages_count
+        self.admins = admins
+        self.restrictions = restrictions
+        self.status = status
+        self.cid = cid
+
+    @classmethod
+    def from_dict(cls, data: dict[Any, Any]) -> "Chat":
+        raw_admins = data.get("adminParticipants", {}) or {}
+        admin_participants: dict[int, dict[Any, Any]] = {
+            int(k): v for k, v in raw_admins.items()
+        }
+        raw_participants = data.get("participants", {}) or {}
+        participants: dict[int, int] = {int(k): v for k, v in raw_participants.items()}
+        last_msg = (
+            Message.from_dict(data["lastMessage"]) if data.get("lastMessage") else None
+        )
+        return cls(
+            participants_count=data.get("participantsCount", 0),
+            access=AccessType(data.get("access", AccessType.PUBLIC.value)),
+            invited_by=data.get("invitedBy"),
+            link=data.get("link"),
+            base_raw_icon_url=data.get("baseRawIconUrl"),
+            base_icon_url=data.get("baseIconUrl"),
+            description=data.get("description"),
+            chat_type=ChatType(data.get("type", ChatType.CHAT.value)),
+            title=data.get("title"),
+            last_fire_delayed_error_time=data.get("lastFireDelayedErrorTime", 0),
+            last_delayed_update_time=data.get("lastDelayedUpdateTime", 0),
+            options=data.get("options", {}),
+            modified=data.get("modified", 0),
+            id_=data.get("id", 0),
+            admin_participants=admin_participants,
+            participants=participants,
+            owner=data.get("owner", 0),
+            join_time=data.get("joinTime", 0),
+            created=data.get("created", 0),
+            last_message=last_msg,
+            prev_message_id=data.get("prevMessageId"),
+            last_event_time=data.get("lastEventTime", 0),
+            messages_count=data.get("messagesCount", 0),
+            admins=data.get("admins", []),
+            restrictions=data.get("restrictions"),
+            status=data.get("status", ""),
+            cid=data.get("cid", 0),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return f"Chat(id={self.id!r}, title={self.title!r}, type={self.type!r})"
+
+    @override
+    def __str__(self) -> str:
+        return f"{self.title} ({self.type})"
+
+
+class Channel(Chat):
+    @override
+    def __repr__(self) -> str:
+        return f"Channel(id={self.id!r}, title={self.title!r})"
+
+    @override
+    def __str__(self) -> str:
+        return f"Channel: {self.title}"
+
+
+class User:
+    def __init__(
+        self,
+        account_status: int,
+        update_time: int,
+        id: int,
+        names: list[Names],
+        options: list[str] | None = None,
+        base_url: str | None = None,
+        base_raw_url: str | None = None,
+        photo_id: int | None = None,
+        description: str | None = None,
+        gender: int | None = None,
+        link: str | None = None,
+        web_app: str | None = None,
+        menu_button: dict[str, Any] | None = None,
+    ) -> None:
+        self.account_status = account_status
+        self.update_time = update_time
+        self.id = id
+        self.names = names
+        self.options = options or []
+        self.base_url = base_url
+        self.base_raw_url = base_raw_url
+        self.photo_id = photo_id
+        self.description = description
+        self.gender = gender
+        self.link = link
+        self.web_app = web_app
+        self.menu_button = menu_button
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "User":
+        return cls(
+            account_status=data["accountStatus"],
+            update_time=data["updateTime"],
+            id=data["id"],
+            names=[Names.from_dict(n) for n in data.get("names", [])],
+            options=data.get("options"),
+            base_url=data.get("baseUrl"),
+            base_raw_url=data.get("baseRawUrl"),
+            photo_id=data.get("photoId"),
+            description=data.get("description"),
+            gender=data.get("gender"),
+            link=data.get("link"),
+            web_app=data.get("webApp"),
+            menu_button=data.get("menuButton"),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return f"User(id={self.id!r}, names={self.names!r}, status={self.account_status!r})"
+
+    @override
+    def __str__(self) -> str:
+        return f"User {self.id}: {', '.join(str(n) for n in self.names)}"
+
+
+class Attach:
+    def __init__(
+        self,
+        _type: AttachType,
+        video_id: int | None = None,
+        photo_token: str | None = None,
+        file_id: int | None = None,
+        token: str | None = None,
+    ) -> None:
+        self.type = _type
+        self.video_id = video_id
+        self.photo_token = photo_token
+        self.file_id = file_id
+        self.token = token
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "Attach":
+        return cls(
+            _type=AttachType(data["type"]),
+            video_id=data.get("videoId"),
+            photo_token=data.get("photoToken"),
+            file_id=data.get("fileId"),
+            token=data.get("token"),
+        )
+
+    @override
+    def __repr__(self) -> str:
+        return (
+            f"Attach(type={self.type!r}, video_id={self.video_id!r}, "
+            f"photo_token={self.photo_token!r}, file_id={self.file_id!r}, token={self.token!r})"
+        )
+
+    @override
+    def __str__(self) -> str:
+        return f"Attach: {self.type}"

pymax/utils.py

@@ -0,0 +1,38 @@
+from typing import Any
+
+import lz4.block
+import msgpack
+
+
+def unpack_packet(data: bytes) -> None | dict[str, Any]:
+    ver = int.from_bytes(data[0:1], "big")
+    cmd = int.from_bytes(data[1:3], "big")
+    seq = int.from_bytes(data[3:4], "big")
+    opcode = int.from_bytes(data[4:6], "big")
+    packed_len = int.from_bytes(data[6:10], "big", signed=False)
+    comp_flag = packed_len >> 24
+    payload_length = packed_len & 0xFFFFFF
+    payload_bytes = data[10 : 10 + payload_length]
+    if comp_flag != 0:
+        compressed_data = payload_bytes
+        try:
+            payload_bytes = lz4.block.decompress(compressed_data, uncompressed_size=255)
+        except lz4.block.LZ4BlockError:
+            return None
+    payload = msgpack.unpackb(payload_bytes, raw=False)
+    return {"ver": ver, "cmd": cmd, "seq": seq, "opcode": opcode, "payload": payload}
+
+
+# ToDo: Add lz4 compression
+def pack_packet(
+    ver: int, cmd: int, seq: int, opcode: int, payload: dict[str, Any]
+) -> bytes:
+    ver_b = ver.to_bytes(1, "big")
+    cmd_b = cmd.to_bytes(2, "big")
+    seq_b = seq.to_bytes(1, "big")
+    opcode_b = opcode.to_bytes(2, "big")
+    payload_bytes = msgpack.packb(payload)
+    if payload_bytes is None:
+        payload_bytes = b""
+    payload_len_b = len(payload_bytes).to_bytes(4, "big")
+    return ver_b + cmd_b + seq_b + opcode_b + payload_len_b + payload_bytes

maxapi_python-0.1.1.dist-info/RECORD

@@ -1,4 +0,0 @@
-maxapi_python-0.1.1.dist-info/METADATA,sha256=uHYKlxE6NA9cmATGtlE_AhF05iJarJmX4fKLCnuMbkE,4812
-maxapi_python-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-maxapi_python-0.1.1.dist-info/licenses/LICENSE,sha256=Ud-0SKeXO_yA02Bb1nMDnEaSGwz2OqNlfGQbk0IzqPI,1085
-maxapi_python-0.1.1.dist-info/RECORD,,