spluspy 2.0.0__tar.gz → 2.0.1__tar.gz

{spluspy-2.0.0 → spluspy-2.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.0.0
+Version: 2.0.1
 Summary: Soroush Plus library for Python
 Home-page: https://github.com/Itskillmaster/spluspy
 Download-URL: https://github.com/Itskillmaster/spluspy/releases

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy/client/updates.py

@@ -477,27 +477,23 @@ class UpdateMethods:
                     updates_to_dispatch.extend(_preprocess_updates)
                     continue
 
-                # Drain all available updates from the queue in one batch
-                # to minimize loop iterations and dispatch latency.
-                pending_updates = []
+                # Drain the update queue aggressively before sleeping
+                got_update = False
                 try:
-                    while True:
-                        pending_updates.append(self._updates_queue.get_nowait())
+                    updates = self._updates_queue.get_nowait()
+                    got_update = True
                 except asyncio.QueueEmpty:
                     pass
 
-                if pending_updates:
-                    for updates in pending_updates:
-                        processed = []
-                        try:
-                            users, chats = self._message_box.process_updates(
-                                updates, self._mb_entity_cache, processed)
-                        except GapError:
-                            continue  # get(_channel)_difference will start returning requests
-
-                        _preprocess_updates = await self._preprocess_updates(
-                            processed, users, chats)
-                        updates_to_dispatch.extend(_preprocess_updates)
+                if got_update:
+                    processed = []
+                    try:
+                        users, chats = self._message_box.process_updates(updates, self._mb_entity_cache, processed)
+                    except GapError:
+                        continue  # get(_channel)_difference will start returning requests
+
+                    _preprocess_updates = await self._preprocess_updates(processed, users, chats)
+                    updates_to_dispatch.extend(_preprocess_updates)
                     continue
 
                 # Wait for next update or deadline
@@ -505,8 +501,7 @@ class UpdateMethods:
                 deadline_delay = deadline - get_running_loop().time()
                 if deadline_delay > 0:
                     try:
-                        updates = await asyncio.wait_for(
-                            self._updates_queue.get(), deadline_delay)
+                        updates = await asyncio.wait_for(self._updates_queue.get(), deadline_delay)
                     except asyncio.TimeoutError:
                         continue
                 else:
@@ -514,13 +509,11 @@ class UpdateMethods:
 
                 processed = []
                 try:
-                    users, chats = self._message_box.process_updates(
-                        updates, self._mb_entity_cache, processed)
+                    users, chats = self._message_box.process_updates(updates, self._mb_entity_cache, processed)
                 except GapError:
                     continue  # get(_channel)_difference will start returning requests
 
-                _preprocess_updates = await self._preprocess_updates(
-                    processed, users, chats)
+                _preprocess_updates = await self._preprocess_updates(processed, users, chats)
                 updates_to_dispatch.extend(_preprocess_updates)
         except asyncio.CancelledError:
             pass

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy/crypto/rsa.py

@@ -266,3 +266,13 @@ eJzmIQvYNmlq5/zb2XxJpZMUAg3iS0nqTQIDAQAB
 -----END RSA PUBLIC KEY-----''',
 ):
     add_key(pub, old=False)
+
+# Add one old key for backward compatibility
+add_key('''-----BEGIN RSA PUBLIC KEY-----
+MIIBCgKCAQEAwACIRK5lXVLU/qPY1VuCssYQjNqh6dUr9UCmkHoOklt7X/Ki1Gqu
+PeVx5VL3NLn64V1heDZqwKZ11NCSS+XBxXh5T2cXRf1Et5USaHtUcU6y0fDFWOBo
+kyehfkJ4KHedI5Z6wkRdSxOVITeBLhIV9OYsa+MuOa7xiD9A8Ogh4Y7k+jA2/zPl
+D41nej3OZEQnDIe762N6J54FzGuKVGtg+NSwkf/h1ULtSg5ifx9bj/vKDNhwdCrm
+Q6IYeDsWwDYm6Rup+9+nUCA/khMpHpzNnEdUwcAa8HQeZCpJX7TZPZRew3T6VhS9
+lv827e/5tL7bohxJrFlyf4BcRzP2I0Nu7QIDAQAB
+-----END RSA PUBLIC KEY-----''', old=True)

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy/network/connection/connection.py

@@ -47,8 +47,8 @@ class Connection(abc.ABC):
         self._recv_task = None
         self._codec = None
         self._obfuscation = None  # TcpObfuscated and MTProxy
-        self._send_queue = asyncio.Queue(1)
-        self._recv_queue = asyncio.Queue(1)
+        self._send_queue = asyncio.Queue(500)
+        self._recv_queue = asyncio.Queue(500)
 
     @staticmethod
     def _wrap_socket_ssl(sock):
@@ -62,7 +62,7 @@ class Connection(abc.ABC):
             sock,
             do_handshake_on_connect=True,
             ssl_version=ssl_mod.PROTOCOL_SSLv23,
-            ciphers='ADH-AES256-SHA')
+            ciphers='ECDHE-RSA-AES128-GCM-SHA256:ECDHE-RSA-AES256-GCM-SHA384:AES128-GCM-SHA256')
 
     @staticmethod
     def _parse_proxy(proxy_type, addr, port, rdns=True, username=None, password=None):
@@ -316,10 +316,25 @@ class Connection(abc.ABC):
     async def _send_loop(self):
         """
         This loop is constantly popping items off the queue to send them.
+
+        Optimized to batch multiple sends before draining to reduce
+        the number of system calls and improve throughput.
         """
         try:
             while self._connected:
-                self._send(await self._send_queue.get())
+                # Wait for first item
+                data = await self._send_queue.get()
+                self._send(data)
+
+                # Try to drain the queue without waiting to batch sends
+                while not self._send_queue.empty():
+                    try:
+                        data = self._send_queue.get_nowait()
+                        self._send(data)
+                    except asyncio.QueueEmpty:
+                        break
+
+                # Drain once after batch
                 await self._writer.drain()
         except asyncio.CancelledError:
             pass

spluspy-2.0.1/spluspy/network/connection/websocket.py

@@ -0,0 +1,313 @@
+import asyncio
+import collections
+import socket
+
+try:
+    import aiohttp
+except ImportError:
+    aiohttp = None
+
+from .tcpabridged import AbridgedPacketCodec
+from .connection import ObfuscatedConnection
+
+from ...crypto import AESModeCTR
+
+import os
+
+
+class WebSocketReader:
+    """
+    Adapter that wraps an aiohttp WebSocket connection to expose
+    the ``readexactly(n)`` interface expected by ``PacketCodec``.
+
+    Uses a deque of received chunks and memoryview for zero-copy slicing
+    to minimize memory allocations under high message rates.
+    """
+    __slots__ = ('_ws', '_chunks', '_chunk_offset', '_total_len')
+
+    def __init__(self, ws):
+        self._ws = ws
+        self._chunks = collections.deque()
+        self._chunk_offset = 0
+        self._total_len = 0
+
+    async def readexactly(self, n):
+        while self._total_len < n:
+            try:
+                msg = await self._ws.receive()
+            except Exception:
+                break
+            if msg.type in (aiohttp.WSMsgType.CLOSE, aiohttp.WSMsgType.CLOSING,
+                            aiohttp.WSMsgType.CLOSED):
+                break
+            if msg.type == aiohttp.WSMsgType.ERROR:
+                break
+            data = msg.data
+            if isinstance(data, str):
+                data = data.encode()
+            self._chunks.append(data)
+            self._total_len += len(data)
+
+        if self._total_len < n:
+            raise IOError('WebSocket closed while reading')
+
+        # Fast path: entire read is within the first chunk
+        first = self._chunks[0]
+        first_avail = len(first) - self._chunk_offset
+        if first_avail >= n:
+            result = first[self._chunk_offset:self._chunk_offset + n]
+            self._chunk_offset += n
+            self._total_len -= n
+            if self._chunk_offset >= len(first):
+                self._chunks.popleft()
+                self._chunk_offset = 0
+            return result
+
+        # Slow path: read spans multiple chunks
+        # Pre-allocate buffer for known size to avoid list growing
+        parts = bytearray(n)
+        offset = 0
+        remaining = n
+
+        if self._chunk_offset > 0:
+            chunk = self._chunks[0]
+            avail = len(chunk) - self._chunk_offset
+            parts[offset:offset + avail] = memoryview(chunk)[self._chunk_offset:]
+            offset += avail
+            remaining -= avail
+            self._chunks.popleft()
+            self._chunk_offset = 0
+
+        while remaining > 0:
+            chunk = self._chunks.popleft()
+            chunk_len = len(chunk)
+            if chunk_len <= remaining:
+                parts[offset:offset + chunk_len] = chunk
+                offset += chunk_len
+                remaining -= chunk_len
+            else:
+                parts[offset:offset + remaining] = memoryview(chunk)[:remaining]
+                self._chunks.appendleft(chunk)
+                self._chunk_offset = remaining
+                remaining = 0
+
+        self._total_len -= n
+        if not self._chunks:
+            self._chunk_offset = 0
+        return bytes(parts)
+
+
+class WebSocketWriter:
+    """
+    Adapter that wraps an aiohttp WebSocket connection to expose
+    the ``write(data)`` / ``drain()`` / ``close()`` interface
+    expected by ``Connection``.
+
+    Buffers pending data in a bytearray and sends in bulk on drain()
+    to reduce syscall overhead.
+    """
+    __slots__ = ('_ws', '_pending')
+
+    def __init__(self, ws):
+        self._ws = ws
+        self._pending = bytearray()
+
+    def write(self, data):
+        self._pending.extend(data)
+
+    async def drain(self):
+        if self._pending:
+            data = bytes(self._pending)
+            self._pending.clear()
+            await self._ws.send_bytes(data)
+
+    def close(self):
+        pass
+
+    async def wait_closed(self):
+        if self._ws is not None:
+            try:
+                await self._ws.close()
+            except Exception:
+                pass
+
+
+class WebSocketObfuscatedIO:
+    """
+    Same obfuscation logic as ``ObfuscatedIO`` in ``tcpobfuscated.py``,
+    but works with ``WebSocketReader`` / ``WebSocketWriter`` adapters.
+    """
+    header = None
+
+    def __init__(self, connection):
+        self._reader = connection._reader
+        self._writer = connection._writer
+
+        (self.header,
+         self._encrypt,
+         self._decrypt) = self._init_header(connection.packet_codec)
+
+    @staticmethod
+    def _init_header(packet_codec):
+        keywords = (b'PVrG', b'GET ', b'POST', b'\xee\xee\xee\xee')
+        while True:
+            random = os.urandom(64)
+            if (random[0] != 0xef and
+                    random[:4] not in keywords and
+                    random[4:8] != b'\0\0\0\0'):
+                break
+
+        random = bytearray(random)
+        random_reversed = random[55:7:-1]
+
+        encrypt_key = bytes(random[8:40])
+        encrypt_iv = bytes(random[40:56])
+        decrypt_key = bytes(random_reversed[:32])
+        decrypt_iv = bytes(random_reversed[32:48])
+
+        encryptor = AESModeCTR(encrypt_key, encrypt_iv)
+        decryptor = AESModeCTR(decrypt_key, decrypt_iv)
+
+        random[56:60] = packet_codec.obfuscate_tag
+        random[56:64] = encryptor.encrypt(bytes(random))[56:64]
+        return (random, encryptor, decryptor)
+
+    async def readexactly(self, n):
+        return self._decrypt.encrypt(await self._reader.readexactly(n))
+
+    def write(self, data):
+        self._writer.write(self._encrypt.encrypt(data))
+
+
+class ConnectionWebSocket(ObfuscatedConnection):
+    """
+    WebSocket transport for Soroush messenger.
+
+    Connects to ``wss://{ip}:{port}/apiws`` with Origin header
+    set to ``https://web.splus.ir``, then uses obfuscated+abridged
+    protocol on top of the WebSocket binary frames.
+    """
+    obfuscated_io = WebSocketObfuscatedIO
+    packet_codec = AbridgedPacketCodec
+    # Class-level session cache to reuse across reconnections
+    _cached_session = None
+    _cached_session_key = None
+
+    async def _connect(self, timeout=None, ssl=None):
+        if aiohttp is None:
+            raise ImportError(
+                'ConnectionWebSocket requires the "aiohttp" package. '
+                'Install it with: pip install aiohttp'
+            )
+
+        protocol = 'wss' if self._port == 443 else 'ws'
+        url = f'{protocol}://{self._ip}:{self._port}/apiws'
+
+        extra_headers = {
+            'Origin': 'https://web.splus.ir'
+        }
+
+        connect_timeout = aiohttp.ClientTimeout(total=timeout) if timeout else None
+        # Reuse cached session if connection parameters haven't changed
+        session_key = (self._ip, self._port, self._proxy, getattr(self, '_local_addr', None))
+        if ConnectionWebSocket._cached_session is not None and ConnectionWebSocket._cached_session_key == session_key:
+            session = ConnectionWebSocket._cached_session
+        else:
+            if ConnectionWebSocket._cached_session is not None:
+                try:
+                    await asyncio.wait_for(ConnectionWebSocket._cached_session.close(), timeout=5)
+                except Exception:
+                    pass
+            session = aiohttp.ClientSession(timeout=connect_timeout)
+            ConnectionWebSocket._cached_session = session
+            ConnectionWebSocket._cached_session_key = session_key
+
+        try:
+            self._ws = await asyncio.wait_for(
+                session.ws_connect(
+                    url,
+                    headers=extra_headers,
+                    protocols=["binary"],
+                    max_msg_size=2 ** 24,  # 16 MB
+                    heartbeat=None,        # MTProto keepalive is used instead
+                ),
+                timeout=timeout
+            )
+        except Exception:
+            # Only close session if it's not cached
+            if session is not ConnectionWebSocket._cached_session:
+                await session.close()
+            raise
+
+        self._session = session
+        self._reader = WebSocketReader(self._ws)
+        self._writer = WebSocketWriter(self._ws)
+
+        # Optimize underlying socket for low latency
+        try:
+            transport = None
+            writer_obj = getattr(self._ws, '_writer', None)
+            if writer_obj is not None:
+                transport = getattr(writer_obj, '_transport', None)
+            if transport is not None and hasattr(transport, 'get_extra_info'):
+                sock = transport.get_extra_info('socket')
+                if sock is not None:
+                    # Disable Nagle's algorithm for lower latency
+                    sock.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+
+                    # Enable TCP keepalive to detect dead connections
+                    sock.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+
+                    # Reduce send/recv buffer sizes for lower memory usage
+                    try:
+                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF, 65536)
+                        sock.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 65536)
+                    except OSError:
+                        pass
+
+                    # Enable TCP Quick ACK on Linux for faster response
+                    try:
+                        TCP_QUICKACK = 12
+                        sock.setsockopt(socket.IPPROTO_TCP, TCP_QUICKACK, 1)
+                    except (OSError, AttributeError):
+                        pass
+        except Exception:
+            pass
+
+        self._codec = self.packet_codec(self)
+        self._init_conn()
+        await self._writer.drain()
+
+    async def disconnect(self):
+        if not self._connected:
+            return
+
+        self._connected = False
+
+        from ... import helpers
+        await helpers._cancel(
+            self._log,
+            send_task=self._send_task,
+            recv_task=self._recv_task
+        )
+
+        if hasattr(self, '_writer') and self._writer:
+            self._writer.close()
+            try:
+                await asyncio.wait_for(self._writer.wait_closed(), timeout=10)
+            except asyncio.TimeoutError:
+                self._log.warning(
+                    'WebSocket disconnection timed out, forcibly ignoring cleanup'
+                )
+            except Exception as e:
+                self._log.info(
+                    '%s during disconnect: %s', type(e), e
+                )
+
+        if hasattr(self, '_session') and self._session:
+            # Don't close session if it's cached for reuse
+            if self._session is not ConnectionWebSocket._cached_session:
+                try:
+                    await asyncio.wait_for(self._session.close(), timeout=5)
+                except Exception:
+                    pass

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy/network/mtprotosender.py

@@ -455,18 +455,18 @@ class MTProtoSender:
         queue, encrypting them, and sending them over the network.
 
         Besides `connect`, only this method ever sends data.
+
+        Optimized to batch pending acks with outgoing messages
+        and reduce encryption overhead.
         """
         while self._user_connected and not self._reconnecting:
             if self._pending_ack:
-                ack = RequestState(MsgsAck(list(self._pending_ack)))
+                ack = RequestState(MsgsAck(self._pending_ack))
                 self._send_queue.append(ack)
                 self._last_acks.append(ack)
                 self._pending_ack.clear()
 
             self._log.debug('Waiting for messages to send...')
-            # TODO Wait for the connection send queue to be empty?
-            # This means that while it's not empty we can wait for
-            # more messages to be added to the send queue.
             batch, data = await self._send_queue.get()
 
             if not data:
@@ -563,10 +563,29 @@ class MTProtoSender:
                 self._start_reconnect(e)
                 return
 
-            try:
-                await self._process_message(message)
-            except Exception:
-                self._log.exception('Unhandled error while processing msgs')
+            # Batch-drain available receives to reduce event-loop overhead
+            batch = [message]
+            while True:
+                try:
+                    next_data = self._connection._recv_queue.get_nowait()
+                    if next_data[1] is not None:
+                        # Error — re-queue and stop batching
+                        await self._connection._recv_queue.put(next_data)
+                        break
+                    next_body = next_data[0]
+                    next_msg = self._state.decrypt_message_data(next_body)
+                    if next_msg is not None:
+                        batch.append(next_msg)
+                except asyncio.QueueEmpty:
+                    break
+                except Exception:
+                    break
+
+            for msg in batch:
+                try:
+                    await self._process_message(msg)
+                except Exception:
+                    self._log.exception('Unhandled error while processing msgs')
 
     # Response Handlers
 

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy/version.py

@@ -1,3 +1,3 @@
 # Versions should comply with PEP440.
 # This line is parsed in setup.py:
-__version__ = '2.0.0'
+__version__ = '2.0.1'

{spluspy-2.0.0 → spluspy-2.0.1}/spluspy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: spluspy
-Version: 2.0.0
+Version: 2.0.1
 Summary: Soroush Plus library for Python
 Home-page: https://github.com/Itskillmaster/spluspy
 Download-URL: https://github.com/Itskillmaster/spluspy/releases