debugpy: Format code.

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

Author: Josverl

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

@@ -64,7 +64,9 @@ def send_response(self, command, request_seq, success=True, body=None, message=N
         if message is not None:
             kwargs["message"] = message
 
-        self._debug_print(f"[DAP] SEND: response {command} (req_seq={request_seq}, success={success})")
+        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:
@@ -95,14 +97,14 @@ def recv_message(self):
                     self._recv_buffer += data
                 except OSError as e:
                     # Handle timeout and other socket errors
-                    if hasattr(e, 'errno') and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
+                    if hasattr(e, "errno") and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
                         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:]
+            self._recv_buffer = self._recv_buffer[header_end + 4 :]
 
             # Parse Content-Length
             content_length = 0
@@ -123,7 +125,7 @@ def recv_message(self):
                         return None
                     self._recv_buffer += data
                 except OSError as e:
-                    if hasattr(e, 'errno') and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
+                    if hasattr(e, "errno") and e.errno in (11, 35):  # EAGAIN, EWOULDBLOCK
                         return None
                     self.closed = True
                     return None
@@ -134,7 +136,9 @@ def recv_message(self):
             # Parse JSON
             try:
                 message = json.loads(body.decode("utf-8"))
-                self._debug_print(f"[DAP] Successfully received message: {message.get('type')} {message.get('command', message.get('event', 'unknown'))}")
+                self._debug_print(
+                    f"[DAP] Successfully received message: {message.get('type')} {message.get('command', message.get('event', 'unknown'))}"
+                )
                 return message
             except (ValueError, UnicodeDecodeError) as e:
                 print(f"[DAP] JSON parse error: {e}")

python-ecosys/debugpy/debugpy/public_api.py

@@ -11,11 +11,11 @@
 
 def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
     """Start listening for debugger connections.
-    
+
     Args:
         port: Port number to listen on (default: 5678)
         host: Host address to bind to (default: "127.0.0.1")
-        
+
     Returns:
         (host, port) tuple of the actual listening address
     """
@@ -52,7 +52,7 @@ def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
         # Handle just the initialize request, then return immediately
         print("[DAP] Waiting for initialize request...")
         init_message = _debug_session.channel.recv_message()
-        if init_message and init_message.get('command') == 'initialize':
+        if init_message and init_message.get("command") == "initialize":
             _debug_session._handle_message(init_message)
             print("[DAP] Initialize request handled - returning control immediately")
         else:
@@ -74,14 +74,15 @@ def listen(port=DEFAULT_PORT, host=DEFAULT_HOST):
 
     return (host, port)
 
+
 def format_client_addr(client_addr):
     """Format client address using socket module methods"""
     if isinstance(client_addr, (tuple, list)):
         # Already in (ip, port) format
         return f"{client_addr[0]}:{client_addr[1]}"
     elif isinstance(client_addr, bytes) and len(client_addr) >= 8:
         # Extract port (bytes 2-4, network byte order)
-        port = struct.unpack('!H', client_addr[2:4])[0]
+        port = struct.unpack("!H", client_addr[2:4])[0]
         # Extract IP address (bytes 4-8) using inet_ntoa
         ip_packed = client_addr[4:8]
         try:
@@ -90,11 +91,12 @@ def format_client_addr(client_addr):
             return f"{ip_addr}:{port}"
         except:
             # Fallback if inet_ntoa not available (MicroPython)
-            ip_addr = '.'.join(str(b) for b in ip_packed)
+            ip_addr = ".".join(str(b) for b in ip_packed)
             return f"{ip_addr}:{port}"
     else:
         return str(client_addr)
 
+
 def wait_for_client():
     """Wait for the debugger client to connect and initialize."""
     global _debug_session
@@ -109,7 +111,7 @@ def breakpoint():
         _debug_session.trigger_breakpoint()
     else:
         # Fallback to built-in breakpoint if available
-        if hasattr(__builtins__, 'breakpoint'):
+        if hasattr(__builtins__, "breakpoint"):
             __builtins__.breakpoint()
 
 
@@ -120,7 +122,7 @@ def debug_this_thread():
         _debug_session.debug_this_thread()
     else:
         # Install trace function even if no session yet
-        if hasattr(sys, 'settrace'):
+        if hasattr(sys, "settrace"):
             sys.settrace(_default_trace_func)
         else:
             raise RuntimeError("MICROPY_PY_SYS_SETTRACE required")
@@ -132,7 +134,6 @@ def _default_trace_func(frame, event, arg):
     return None
 
 
-
 def is_client_connected():
     """Check if a debugger client is connected."""
     global _debug_session

python-ecosys/debugpy/debugpy/server/debug_session.py

@@ -3,12 +3,34 @@
 import sys
 from ..common.messaging import JsonMessageChannel
 from ..common.constants import (
-    CMD_INITIALIZE, CMD_LAUNCH, CMD_ATTACH, CMD_SET_BREAKPOINTS,
-    CMD_CONTINUE, CMD_NEXT, CMD_STEP_IN, CMD_STEP_OUT, CMD_PAUSE,
-    CMD_STACK_TRACE, CMD_SCOPES, CMD_VARIABLES, CMD_EVALUATE, CMD_DISCONNECT,
-    CMD_CONFIGURATION_DONE, CMD_THREADS, CMD_SOURCE, EVENT_INITIALIZED, EVENT_STOPPED, EVENT_CONTINUED, EVENT_TERMINATED,
-    STOP_REASON_BREAKPOINT, STOP_REASON_STEP, STOP_REASON_PAUSE,
-    TRACE_CALL, TRACE_LINE, TRACE_RETURN, TRACE_EXCEPTION
+    CMD_INITIALIZE,
+    CMD_LAUNCH,
+    CMD_ATTACH,
+    CMD_SET_BREAKPOINTS,
+    CMD_CONTINUE,
+    CMD_NEXT,
+    CMD_STEP_IN,
+    CMD_STEP_OUT,
+    CMD_PAUSE,
+    CMD_STACK_TRACE,
+    CMD_SCOPES,
+    CMD_VARIABLES,
+    CMD_EVALUATE,
+    CMD_DISCONNECT,
+    CMD_CONFIGURATION_DONE,
+    CMD_THREADS,
+    CMD_SOURCE,
+    EVENT_INITIALIZED,
+    EVENT_STOPPED,
+    EVENT_CONTINUED,
+    EVENT_TERMINATED,
+    STOP_REASON_BREAKPOINT,
+    STOP_REASON_STEP,
+    STOP_REASON_PAUSE,
+    TRACE_CALL,
+    TRACE_LINE,
+    TRACE_RETURN,
+    TRACE_EXCEPTION,
 )
 from .pdb_adapter import PdbAdapter
 
@@ -34,7 +56,7 @@ def _debug_print(self, message):
 
     @property
     def _baremetal(self) -> bool:
-        return sys.platform not in ("linux") # to be expanded
+        return sys.platform not in ("linux")  # to be expanded
 
     def start(self):
         """Start the debug session message loop."""
@@ -77,7 +99,7 @@ def initialize_connection(self):
                     message_count += 1
 
                     # Just wait for attach, then we can return control
-                    if message.get('command') == 'attach':
+                    if message.get("command") == "attach":
                         attached = True
                         print("[DAP] ✅ Attach received - returning control to main thread")
                         break
@@ -191,12 +213,12 @@ def _handle_request(self, message):
             elif command == CMD_SOURCE:
                 self._handle_source(seq, args)
             else:
-                self.channel.send_response(command, seq, success=False,
-                                         message=f"Unknown command: {command}")
+                self.channel.send_response(
+                    command, seq, success=False, message=f"Unknown command: {command}"
+                )
 
         except Exception as e:
-            self.channel.send_response(command, seq, success=False,
-                                     message=str(e))
+            self.channel.send_response(command, seq, success=False, message=str(e))
 
     def _handle_initialize(self, seq, args):
         """Handle initialize request."""
@@ -251,16 +273,15 @@ def _handle_attach(self, seq, args):
         self.debug_logging = args.get("logToFile", False)
 
         self._debug_print(f"[DAP] Processing attach request with args: {args}")
-        print(f"[DAP] Debug logging {'enabled' if self.debug_logging else 'disabled'} (logToFile={self.debug_logging})")
-        
+        print(
+            f"[DAP] Debug logging {'enabled' if self.debug_logging else 'disabled'} (logToFile={self.debug_logging})"
+        )
+
         # get debugger root and debugee root from pathMappings
-        for pm in args.get("pathMappings",[]):
+        for pm in args.get("pathMappings", []):
             # debugee - debugger
-            self.pdb.path_mappings.append(
-                (pm.get("remoteRoot", "./"),
-                 pm.get("localRoot", "./"))
-            )
-        # # TODO: justMyCode, debugOptions  , 
+            self.pdb.path_mappings.append((pm.get("remoteRoot", "./"), pm.get("localRoot", "./")))
+        # # TODO: justMyCode, debugOptions  ,
 
         # Enable trace function
         self.pdb.set_trace_function(self._trace_function)
@@ -282,8 +303,9 @@ def _handle_set_breakpoints(self, seq, args):
         # Set breakpoints in pdb adapter
         actual_breakpoints = self.pdb.set_breakpoints(filename, breakpoints)
 
-        self.channel.send_response(CMD_SET_BREAKPOINTS, seq,
-                                 body={"breakpoints": actual_breakpoints})
+        self.channel.send_response(
+            CMD_SET_BREAKPOINTS, seq, body={"breakpoints": actual_breakpoints}
+        )
 
     def _handle_continue(self, seq, args):
         """Handle continue request."""
@@ -322,8 +344,11 @@ def _handle_pause(self, seq, args):
     def _handle_stack_trace(self, seq, args):
         """Handle stackTrace request."""
         stack_frames = self.pdb.get_stack_trace()
-        self.channel.send_response(CMD_STACK_TRACE, seq,
-                                 body={"stackFrames": stack_frames, "totalFrames": len(stack_frames)})
+        self.channel.send_response(
+            CMD_STACK_TRACE,
+            seq,
+            body={"stackFrames": stack_frames, "totalFrames": len(stack_frames)},
+        )
 
     def _handle_scopes(self, seq, args):
         """Handle scopes request."""
@@ -345,18 +370,17 @@ def _handle_evaluate(self, seq, args):
         frame_id = args.get("frameId")
         context = args.get("context", "watch")
         if not expression:
-            self.channel.send_response(CMD_EVALUATE, seq, success=False,
-                                     message="No expression provided")
+            self.channel.send_response(
+                CMD_EVALUATE, seq, success=False, message="No expression provided"
+            )
             return
         try:
             result = self.pdb.evaluate_expression(expression, frame_id)
-            self.channel.send_response(CMD_EVALUATE, seq, body={
-                "result": str(result),
-                "variablesReference": 0
-            })
+            self.channel.send_response(
+                CMD_EVALUATE, seq, body={"result": str(result), "variablesReference": 0}
+            )
         except Exception as e:
-            self.channel.send_response(CMD_EVALUATE, seq, success=False,
-                                     message=str(e))
+            self.channel.send_response(CMD_EVALUATE, seq, success=False, message=str(e))
 
     def _handle_disconnect(self, seq, args):
         """Handle disconnect request."""
@@ -372,10 +396,7 @@ def _handle_configuration_done(self, seq, args):
     def _handle_threads(self, seq, args):
         """Handle threads request."""
         # MicroPython is single-threaded, so return one thread
-        threads = [{
-            "id": self.thread_id,
-            "name": "main"
-        }]
+        threads = [{"id": self.thread_id, "name": "main"}]
         self.channel.send_response(CMD_THREADS, seq, body={"threads": threads})
 
     def _handle_source(self, seq, args):
@@ -395,10 +416,13 @@ def _handle_source(self, seq, args):
                 content = f.read()
             self.channel.send_response(CMD_SOURCE, seq, body={"content": content})
         except Exception:
-            self.channel.send_response(CMD_SOURCE, seq, success=False,
-                                    message="cancelled"
-                                    #  message=f"Could not read source: {e}"
-                                     )
+            self.channel.send_response(
+                CMD_SOURCE,
+                seq,
+                success=False,
+                message="cancelled",
+                #  message=f"Could not read source: {e}"
+            )
 
     def _trace_function(self, frame, event, arg):
         """Trace function called by sys.settrace."""
@@ -407,19 +431,23 @@ def _trace_function(self, frame, event, arg):
 
         # Handle breakpoints and stepping
         if self.pdb.should_stop(frame, event, arg):
-            self._send_stopped_event(STOP_REASON_BREAKPOINT if self.pdb.hit_breakpoint else
-                                   STOP_REASON_STEP if self.stepping else STOP_REASON_PAUSE)
+            self._send_stopped_event(
+                STOP_REASON_BREAKPOINT
+                if self.pdb.hit_breakpoint
+                else STOP_REASON_STEP
+                if self.stepping
+                else STOP_REASON_PAUSE
+            )
             # Wait for continue command
             self.pdb.wait_for_continue()
 
         return self._trace_function
 
     def _send_stopped_event(self, reason):
         """Send stopped event to client."""
-        self.channel.send_event(EVENT_STOPPED,
-                              reason=reason,
-                              threadId=self.thread_id,
-                              allThreadsStopped=True)
+        self.channel.send_event(
+            EVENT_STOPPED, reason=reason, threadId=self.thread_id, allThreadsStopped=True
+        )
 
     def wait_for_client(self):
         """Wait for client to initialize."""
@@ -433,7 +461,7 @@ def trigger_breakpoint(self):
 
     def debug_this_thread(self):
         """Enable debugging for current thread."""
-        if hasattr(sys, 'settrace'):
+        if hasattr(sys, "settrace"):
             sys.settrace(self._trace_function)
 
     def is_connected(self):
@@ -443,7 +471,7 @@ def is_connected(self):
     def disconnect(self):
         """Disconnect from client."""
         self.connected = False
-        if hasattr(sys, 'settrace'):
+        if hasattr(sys, "settrace"):
             sys.settrace(None)
         self.pdb.cleanup()
         self.channel.close()