debugpy : Format code.

Signed-off-by: Jos Verlinde <[email protected]>

Author: Josverl

python-ecosys/debugpy/dap_monitor.py

@@ -16,35 +16,35 @@ def __init__(self, listen_port=5679, target_host='127.0.0.1', target_port=5678):
         self.target_port = target_port
         self.client_sock = None
         self.server_sock = None
-        
+
     def start(self):
         """Start the DAP monitor proxy."""
         print(f"DAP Monitor starting on port {self.listen_port}")
         print(f"Will forward to {self.target_host}:{self.target_port}")
         print("Start MicroPython debugpy server first, then connect VS Code to port 5679")
-        
+
         # Create listening socket
         listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
         listener.bind(('127.0.0.1', self.listen_port))
         listener.listen(1)
-        
+
         print(f"Listening for VS Code connection on port {self.listen_port}...")
-        
+
         try:
             # Wait for VS Code to connect
             self.client_sock, client_addr = listener.accept()
             print(f"VS Code connected from {client_addr}")
-            
+
             # Connect to MicroPython debugpy server
             self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
             self.server_sock.connect((self.target_host, self.target_port))
             print(f"Connected to MicroPython debugpy at {self.target_host}:{self.target_port}")
-            
+
             # Start forwarding threads
             threading.Thread(target=self.forward_client_to_server, daemon=True).start()
             threading.Thread(target=self.forward_server_to_client, daemon=True).start()
-            
+
             print("DAP Monitor active - press Ctrl+C to stop")
             while not self.disconnect:
                 time.sleep(1)
@@ -55,7 +55,7 @@ def start(self):
             print(f"Error: {e}")
         finally:
             self.cleanup()
-            
+
     def forward_client_to_server(self):
         """Forward messages from VS Code client to MicroPython server."""
         try:
@@ -66,7 +66,7 @@ def forward_client_to_server(self):
                 self.send_raw_data(self.server_sock, data)
         except Exception as e:
             print(f"Client->Server forwarding error: {e}")
-            
+
     def forward_server_to_client(self):
         """Forward messages from MicroPython server to VS Code client."""
         try:
@@ -77,7 +77,7 @@ def forward_server_to_client(self):
                 self.send_raw_data(self.client_sock, data)
         except Exception as e:
             print(f"Server->Client forwarding error: {e}")
-            
+
     def receive_dap_message(self, sock, source):
         """Receive and log a DAP message."""
         try:
@@ -88,26 +88,26 @@ def receive_dap_message(self, sock, source):
                 if not byte:
                     return None
                 header += byte
-                
+
             # Parse content length
             header_str = header.decode('utf-8')
             content_length = 0
             for line in header_str.split('\r\n'):
                 if line.startswith('Content-Length:'):
                     content_length = int(line.split(':', 1)[1].strip())
                     break
-                    
+
             if content_length == 0:
                 return None
-                
+
             # Read content
             content = b""
             while len(content) < content_length:
                 chunk = sock.recv(content_length - len(content))
                 if not chunk:
                     return None
                 content += chunk
-                
+
             # Parse and Log the message
             message = self.parse_dap(source, content)
             self.log_dap_message(source, message)
@@ -163,7 +163,7 @@ def send_raw_data(self, sock, data):
             sock.send(data)
         except Exception as e:
             print(f"Error sending data: {e}")
-            
+
     def cleanup(self):
         """Clean up sockets."""
         if self.client_sock:
@@ -184,4 +184,4 @@ def cleanup(self):
         target_host=args.target_host,
         target_port=args.target_port
     )
-    monitor.start()
+    monitor.start()

python-ecosys/debugpy/debugpy/__init__.py

@@ -11,10 +11,10 @@
 from .common.constants import DEFAULT_HOST, DEFAULT_PORT
 
 __all__ = [
-    "listen",
-    "wait_for_client", 
-    "breakpoint",
-    "debug_this_thread",
     "DEFAULT_HOST",
     "DEFAULT_PORT",
+    "breakpoint",
+    "debug_this_thread",
+    "listen",
+    "wait_for_client",
 ]

python-ecosys/debugpy/debugpy/common/messaging.py

@@ -6,25 +6,25 @@
 
 class JsonMessageChannel:
     """Handles JSON message communication over a socket using DAP format."""
-    
+
     def __init__(self, sock, debug_callback=None):
         self.sock = sock
         self.seq = 0
         self.closed = False
         self._recv_buffer = b""
         self._debug_print = debug_callback or (lambda x: None)  # Default to no-op
-        
+
     def send_message(self, msg_type, command=None, **kwargs):
         """Send a DAP message."""
         if self.closed:
             return
-            
+
         self.seq += 1
         message = {
             "seq": self.seq,
             "type": msg_type,
         }
-        
+
         if command:
             if msg_type == MSG_TYPE_REQUEST:
                 message["command"] = command
@@ -42,48 +42,48 @@ def send_message(self, msg_type, command=None, **kwargs):
                 message["event"] = command
                 if kwargs:
                     message["body"] = kwargs
-        
+
         json_str = json.dumps(message)
         content = json_str.encode("utf-8")
         header = f"Content-Length: {len(content)}\r\n\r\n".encode("utf-8")
-        
+
         try:
             self.sock.send(header + content)
         except OSError:
             self.closed = True
-            
+
     def send_request(self, command, **kwargs):
         """Send a request message."""
         self.send_message(MSG_TYPE_REQUEST, command, **kwargs)
-        
+
     def send_response(self, command, request_seq, success=True, body=None, message=None):
         """Send a response message."""
         kwargs = {"request_seq": request_seq, "success": success}
         if body is not None:
             kwargs["body"] = body
         if message is not None:
             kwargs["message"] = message
-        
+
         self._debug_print(f"[DAP] SEND: response {command} (req_seq={request_seq}, success={success})")
         if body:
             self._debug_print(f"[DAP]   body: {body}")
         if message:
             self._debug_print(f"[DAP]   message: {message}")
-            
+
         self.send_message(MSG_TYPE_RESPONSE, command, **kwargs)
-        
+
     def send_event(self, event, **kwargs):
         """Send an event message."""
         self._debug_print(f"[DAP] SEND: event {event}")
         if kwargs:
             self._debug_print(f"[DAP]   body: {kwargs}")
         self.send_message(MSG_TYPE_EVENT, event, **kwargs)
-        
+
     def recv_message(self):
         """Receive a DAP message."""
         if self.closed:
             return None
-            
+
         try:
             # Read headers
             while b"\r\n\r\n" not in self._recv_buffer:
@@ -99,21 +99,21 @@ def recv_message(self):
                         return None  # No data available
                     self.closed = True
                     return None
-                
+
             header_end = self._recv_buffer.find(b"\r\n\r\n")
             header_str = self._recv_buffer[:header_end].decode("utf-8")
             self._recv_buffer = self._recv_buffer[header_end + 4:]
-            
+
             # Parse Content-Length
             content_length = 0
             for line in header_str.split("\r\n"):
                 if line.startswith("Content-Length:"):
                     content_length = int(line.split(":", 1)[1].strip())
                     break
-                    
+
             if content_length == 0:
                 return None
-                
+
             # Read body
             while len(self._recv_buffer) < content_length:
                 try:
@@ -127,10 +127,10 @@ def recv_message(self):
                         return None
                     self.closed = True
                     return None
-                
+
             body = self._recv_buffer[:content_length]
             self._recv_buffer = self._recv_buffer[content_length:]
-            
+
             # Parse JSON
             try:
                 message = json.loads(body.decode("utf-8"))
@@ -139,12 +139,12 @@ def recv_message(self):
             except (ValueError, UnicodeDecodeError) as e:
                 print(f"[DAP] JSON parse error: {e}")
                 return None
-                
+
         except OSError as e:
             print(f"[DAP] Socket error in recv_message: {e}")
             self.closed = True
             return None
-            
+
     def close(self):
         """Close the channel."""
         self.closed = True

python-ecosys/debugpy/debugpy/public_api.py

@@ -19,35 +19,35 @@ def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
         (host, port) tuple of the actual listening address
     """
     global _debug_session
-    
+
     if _debug_session is not None:
         raise RuntimeError("Already listening for debugger")
-        
+
     # Create listening socket
     listener = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
     try:
         listener.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
     except:
         pass  # Not supported in MicroPython
-    
+
     # Use getaddrinfo for MicroPython compatibility
     addr_info = socket.getaddrinfo(host, port)
     addr = addr_info[0][-1]  # Get the sockaddr
     listener.bind(addr)
     listener.listen(1)
-    
+
     # getsockname not available in MicroPython, use original values
     print(f"Debugpy listening on {host}:{port}")
-    
+
     # Wait for connection
     client_sock = None
     try:
         client_sock, client_addr = listener.accept()
         print(f"Debugger connected from {client_addr}")
-        
+
         # Create debug session
         _debug_session = DebugSession(client_sock)
-        
+
         # Handle just the initialize request, then return immediately
         print("[DAP] Waiting for initialize request...")
         init_message = _debug_session.channel.recv_message()
@@ -56,12 +56,12 @@ def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
             print("[DAP] Initialize request handled - returning control immediately")
         else:
             print(f"[DAP] Warning: Expected initialize, got {init_message}")
-            
+
         # Set socket to non-blocking for subsequent message processing
         _debug_session.channel.sock.settimeout(0.001)
-        
+
         print("[DAP] Debug session ready - all other messages will be handled in trace function")
-        
+
     except Exception as e:
         print(f"[DAP] Connection error: {e}")
         if client_sock:
@@ -70,7 +70,7 @@ def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
     finally:
         # Only close the listener, not the client connection
         listener.close()
-        
+
     return (host, port)