socketflow 0.2.0__tar.gz → 0.2.2__tar.gz

{socketflow-0.2.0 → socketflow-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socketflow
-Version: 0.2.0
+Version: 0.2.2
 Summary: TCP networking for Python, without the boilerplate.
 Home-page: https://github.com/ayammaximilian/socketflow
 Author: SocketFlow Team

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/__init__.py

@@ -34,7 +34,7 @@ from .global_side.protocol import (
     MAX_PROTOCOL_VERSION,
 )
 
-__version__ = "0.2.0"
+__version__ = "0.2.2"
 __all__ = [
     "TcpServer",
     "TcpClient",

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/client_side/client.py

@@ -169,7 +169,10 @@ class TcpClientProtocol:
                         else "Authentication failed"
                     )
                 self.client._auth_ack_event.set()
-                if self.client._auth_error is not None or not self.client.require_handshake:
+                if (
+                    self.client._auth_error is not None
+                    or not self.client.require_handshake
+                ):
                     self.client._auth_event.set()
                 continue
             elif msg_type == "__handshake_ok__":
@@ -182,9 +185,7 @@ class TcpClientProtocol:
                 server_addr = self.client._server_addr
                 if not server_addr:
                     server_addr = (
-                        self.socket.getpeername()
-                        if self.socket
-                        else ("unknown", 0)
+                        self.socket.getpeername() if self.socket else ("unknown", 0)
                     )
                 wait_response = headers.get("wait_response", False)
                 status_code = headers.get("status_code", 200)
@@ -200,9 +201,7 @@ class TcpClientProtocol:
                 )
 
                 # Resolve pending wait_response futures
-                future = (
-                    self.client.pending_responses.pop(data_id) if data_id else None
-                )
+                future = self.client.pending_responses.pop(data_id) if data_id else None
                 if future is not None:
                     if not future.done():
                         future.set_result(
@@ -236,6 +235,12 @@ class TcpClientProtocol:
         with self._control_lock:
             self.socket.sendall(data)
 
+    def has_backpressure(self) -> bool:
+        """True when the outbound queue to the server is full."""
+        if self._writer is None:
+            return False
+        return self._writer.has_backpressure()
+
     def close(self):
         self._writer.abort()
 
@@ -287,7 +292,10 @@ class TcpClientProtocol:
         try:
             self.send_data(message_handler.create_ping())
         except Exception:
-            return
+            # A failed write is evidence the peer is gone. Do not return here,
+            # or the silence check below is skipped and a dead connection is
+            # never detected. Fall through and let that check decide.
+            pass
 
         if now - self._last_received_at >= interval * max(
             self.client.keepalive_max_missed, 1
@@ -362,25 +370,29 @@ class TcpClient:
         if handshake_timeout is not None and handshake_timeout <= 0:
             raise ValueError("handshake_timeout must be positive")
         if (auth_username is None) != (auth_password is None):
-            raise ValueError("auth_username and auth_password must be provided together")
+            raise ValueError(
+                "auth_username and auth_password must be provided together"
+            )
         if auth_token is not None and auth_username is not None:
-            raise ValueError("Use either auth_token or username/password authentication")
+            raise ValueError(
+                "Use either auth_token or username/password authentication"
+            )
         if min_protocol_version is not None and max_protocol_version is not None:
             if min_protocol_version > max_protocol_version:
                 raise ValueError(
                     "min_protocol_version cannot exceed max_protocol_version"
                 )
         if (tls_certfile is None) != (tls_keyfile is None):
-            raise ValueError(
-                "tls_certfile and tls_keyfile must be provided together"
-            )
+            raise ValueError("tls_certfile and tls_keyfile must be provided together")
 
         self.host = host
         self.port = port
         self.metrics = metrics_module.MetricsRegistry()
         self._log = logs.get_logger("socketflow.client")
         self.metrics.describe("messages_sent_total", "Messages sent to the server")
-        self.metrics.describe("messages_received_total", "Messages received from the server")
+        self.metrics.describe(
+            "messages_received_total", "Messages received from the server"
+        )
         self.metrics.describe("bytes_sent_total", "Bytes written to the server")
         self.metrics.describe("errors_total", "Errors by context")
         self.metrics.describe("backpressure_total", "Rejections caused by full queues")
@@ -503,6 +515,7 @@ class TcpClient:
                 return
             self._negotiated_version = agreed
         self._server_ready_event.set()
+
     def _on_protocol_error(self, body):
         """Record a server-side version refusal."""
         reason = "Server refused the protocol version"
@@ -607,8 +620,6 @@ class TcpClient:
         self._protocol = None
         self._connected = False
 
-
-
     def connect(self):
         """Connect to server"""
         if self._connected:
@@ -887,13 +898,9 @@ class TcpClient:
         if not self._connected:
             raise ExceptionType.NotConnected("Client is not connected")
         if self.require_handshake and not self._handshake_completed:
-            raise ExceptionType.HandshakeError(
-                "Connection handshake is not complete"
-            )
+            raise ExceptionType.HandshakeError("Connection handshake is not complete")
 
-        data_id, frame = self._encode_outbound(
-            data, data_id, path, True, status_code
-        )
+        data_id, frame = self._encode_outbound(data, data_id, path, True, status_code)
         self._record_send(path, frame)
 
         # Register before sending because the peer can reply before send returns.
@@ -965,9 +972,7 @@ class TcpClient:
                 f"No response received within {wait_response_timeout}"
             )
         except Exception as e:
-            raise ExceptionType.ClientError(
-                f"Error while waiting for response: {e}"
-            )
+            raise ExceptionType.ClientError(f"Error while waiting for response: {e}")
         finally:
             request.cancel()
 
@@ -987,6 +992,13 @@ class TcpClient:
     def is_connected(self):
         return self._connected
 
+    def has_backpressure(self) -> bool:
+        """True when the outbound queue to the server is full."""
+        protocol = self._protocol
+        if protocol is None:
+            return False
+        return protocol.has_backpressure()
+
     @property
     def handshake_completed(self):
         return self._handshake_completed

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/global_side/blueprint.py

@@ -78,6 +78,22 @@ class Blueprint:
                 "Blueprint not registered with client or server"
             )
 
+    def has_backpressure(self, client_addr: tuple = None) -> bool:
+        """True when the outbound queue is full.
+
+        On a server blueprint, client_addr selects the client to check.
+        """
+        if hasattr(self, "_client") and self._client:
+            return self._client.has_backpressure()
+        elif hasattr(self, "_server") and self._server:
+            if not client_addr:
+                raise ExceptionType.BlueprintError("client_addr parameter is required")
+            return self._server.has_backpressure(client_addr)
+        else:
+            raise ExceptionType.BlueprintError(
+                "Blueprint not registered with client or server"
+            )
+
     def send(
         self,
         data: Any,

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/global_side/event_loop.py

@@ -176,6 +176,12 @@ class EventLoopWriter:
             return True
         return self.connection.flush(timeout)
 
+    def has_backpressure(self) -> bool:
+        """True when the next send would raise Backpressure."""
+        if self.connection is None:
+            return False
+        return self.connection.has_backpressure()
+
     def abort(self, timeout=1.0):
         if self.connection is not None:
             self.connection.close()
@@ -233,6 +239,14 @@ class _SelectorConnection:
         with self._lock:
             return self._pending_writes
 
+    def has_backpressure(self) -> bool:
+        """True when the next send would raise Backpressure."""
+        with self._lock:
+            return (
+                self._pending_writes >= self._max_pending_writes
+                or self._queued_bytes >= self._max_queue_bytes
+            )
+
     def flush(self, timeout: float = 5.0) -> bool:
         """Wait until the send buffer is empty.
 

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/global_side/transport.py

@@ -50,7 +50,6 @@ class MemoryBudget:
             self._used_bytes = max(0, self._used_bytes - amount)
 
 
-
 class TimeoutScheduler:
     """Run request timeouts from a single shared thread.
 
@@ -217,7 +216,9 @@ class PendingResponseRegistry:
         key = self._key(data_id, owner)
         with self._lock:
             if key in self._responses:
-                raise ValueError(f"A request with data_id {data_id!r} is already pending")
+                raise ValueError(
+                    f"A request with data_id {data_id!r} is already pending"
+                )
             self._responses[key] = future
 
     def pop(self, data_id: str, owner: Any = None) -> Optional[Any]:
@@ -335,6 +336,14 @@ class SocketWriter:
                 return False
             time.sleep(0.002)
 
+    def has_backpressure(self) -> bool:
+        """True when the next send would raise Backpressure."""
+        with self._state_lock:
+            return (
+                self._pending_writes >= self._max_pending_writes
+                or self._queued_bytes >= self._max_queue_bytes
+            )
+
     def _complete(self, payload: bytes):
         with self._state_lock:
             self._queued_bytes -= len(payload)

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow/server_side/server.py

@@ -436,6 +436,12 @@ class TcpServerProtocol:
         except Exception:
             return False
 
+    def has_backpressure(self) -> bool:
+        """True when the outbound queue to this client is full."""
+        if self._writer is None:
+            return False
+        return self._writer.has_backpressure()
+
     def close(self):
         if self._writer is not None:
             self._writer.abort()
@@ -504,7 +510,10 @@ class TcpServerProtocol:
         try:
             self.send(message_handler.create_ping())
         except Exception:
-            return
+            # A failed write is evidence the peer is gone. Do not return here,
+            # or the silence check below is skipped and a dead connection is
+            # never detected. Fall through and let that check decide.
+            pass
 
         if now - self._last_received_at >= interval * max(
             self.server.keepalive_max_missed, 1
@@ -1429,6 +1438,17 @@ class TcpServer:
         with self._clients_lock:
             return client_addr in self._clients
 
+    def has_backpressure(self, client_addr) -> bool:
+        """True when the outbound queue to one client is full.
+
+        Returns False when the client is not connected.
+        """
+        with self._clients_lock:
+            protocol = self._clients.get(client_addr)
+        if protocol is None:
+            return False
+        return protocol.has_backpressure()
+
     def get_client_identity(self, client_addr: tuple) -> Optional[str]:
         """Return the verified certificate common name for a client, or None."""
         with self._clients_lock:

{socketflow-0.2.0 → socketflow-0.2.2}/socketflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: socketflow
-Version: 0.2.0
+Version: 0.2.2
 Summary: TCP networking for Python, without the boilerplate.
 Home-page: https://github.com/ayammaximilian/socketflow
 Author: SocketFlow Team