socketflow 0.2.1__tar.gz → 0.2.3__tar.gz

{socketflow-0.2.1 → socketflow-0.2.3}/PKG-INFO

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

{socketflow-0.2.1 → socketflow-0.2.3}/socketflow/__init__.py

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

{socketflow-0.2.1 → socketflow-0.2.3}/socketflow/client_side/client.py

@@ -235,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()
 
@@ -986,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.1 → socketflow-0.2.3}/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.1 → socketflow-0.2.3}/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.1 → socketflow-0.2.3}/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.1 → socketflow-0.2.3}/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()
@@ -815,20 +821,17 @@ class TcpServer:
             pass
 
         protocol.attach_socket(client_socket)
-        try:
-            protocol._send_server_ready()
-        except Exception:
-            protocol.handle_connection_lost()
-            return
         with self._clients_lock:
             self._clients[address] = protocol
-
         try:
+            protocol._send_server_ready()
             if not self.auth_required:
+                if self.require_handshake:
+                    protocol._send_handshake_ok()
                 protocol._notify_connected()
         except Exception:
             protocol.handle_connection_lost()
-            raise
+            return
 
         while True:
             try:
@@ -943,6 +946,10 @@ class TcpServer:
                 self._clients[address] = protocol
             protocol._event_loop_mode = False
             protocol._send_server_ready()
+            if not self.auth_required:
+                if self.require_handshake:
+                    protocol._send_handshake_ok()
+                protocol._notify_connected()
             protocol._event_loop_mode = True
 
             def on_close():
@@ -962,8 +969,6 @@ class TcpServer:
                 memory_budget=self.memory_budget,
             )
             registered = True
-            if not self.auth_required and not self.require_handshake:
-                protocol._notify_connected()
         except Exception as error:
             if protocol is not None:
                 protocol.handle_connection_lost()
@@ -1432,6 +1437,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.1 → socketflow-0.2.3}/socketflow.egg-info/PKG-INFO

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