mirrors/debugpy
1
0
Fork 0
mirror of https://github.com/microsoft/debugpy.git synced 2025-12-23 08:48:12 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 2

Fix #896: Changes in CLI arguments between versions

Browse source 
Merge changes from v4.1.4-branch into master.
This commit is contained in:
Pavel Minaev 2018-10-18 15:02:34 -07:00
commit c7ee9277f3
5 changed files with 83 additions and 205 deletions
Download patch file Download diff file Expand all files Collapse all files

71
README.md
View file

@ -6,70 +6,69 @@
[![PyPI](https://img.shields.io/pypi/v/ptvsd.svg)](https://pypi.org/project/ptvsd/)
## `ptvsd` CLI Usage
### Debug a script file
Use this to launch your script file. Launch script file without waiting for debugger to attach.
### Debugging a script file
To run a script file with debugging enabled, but without waiting for the debugger to attach (i.e. code starts executing immediately):
```console
-m ptvsd --port 5678 myfile.py
-m ptvsd --host localhost --port 5678 myfile.py
```
If you want the debugger to attach before running your code use `--wait` flag.
To wait until the debugger attaches before running your code, use the `--wait` switch.
```console
-m ptvsd --port 5678 --wait myfile.py
-m ptvsd --host localhost --port 5678 --wait myfile.py
```
The `--host` option specifies the interface on which the debug server is listening for connections. To be able to attach from another machine, make sure that the server is listening on a public interface - using `0.0.0.0` will make it listen on all available interfaces:
```console
-m ptvsd --host 0.0.0.0 --port 5678 myfile.py
```
This should only be done on secure networks, since anyone who can connect to the specified port can then execute arbitrary code within the debugged process.
### Debug a module
Use this to launch your module. Launch script file without waiting for debugger to attach.
```console
-m ptvsd --port 5678 -m mymodule
```
If you want the debugger to attach before running your code use `--wait` flag.
```console
-m ptvsd --port 5678 --wait -m mymodule
```
To pass arguments to the script, just specify them after the filename. This works the same as with Python itself - everything up to the filename is processed by ptvsd, but everything after that becomes `sys.argv` of the running process.
### Debug a process by id
Attach to a process running python code.
### Debugging a module
To run a module, use the `-m` switch instead of filename:
```console
-m ptvsd --host 0.0.0.0 --port 5678 --pid 12345
-m ptvsd --host localhost --port 5678 -m mymodule
```
Same as with scripts, command line arguments can be passed to the module by specifying them after the module name. All other ptvsd switches work identically in this mode; in particular, `--wait` can be used to block execution until debugger attaches.
### Attaching to a running process by ID
The following command injects the debugger into a process with a given PID that is running Python code. Once the command returns, a ptvsd server is running within the process, as if that process was launched via `-m ptvsd` itself.
```console
-m ptvsd --host localhost --port 5678 --pid 12345
```
## `ptvsd` Import usage
### Enable debugging
In your script import ptvsd and call `enable_attach` to enable the process to attach to the debugger. The default port is 5678. You can configure this while calling `enable_attach`.
### Enabling debugging
At the beginning of your script, import ptvsd, and call `ptvsd.enable_attach()` to start the debug server. The default hostname is `0.0.0.0`, and the default port is 5678; these can be overridden by passing a `(host, port)` tuple as the first argument of `enable_attach()`.
```python
import ptvsd
ptvsd.enable_attach()
# your code
...
```
### Wait for attach
Use the `wait_for_attach()` function to block execution until debugger is attached.
### Waiting for debugger to attach
Use the `ptvsd.wait_for_attach()` function to block program execution until debugger is attached.
```python
import ptvsd
ptvsd.enable_attach()
# script execution will stop here till debugger is attached
ptvsd.wait_for_attach()
# your code
ptvsd.wait_for_attach() # blocks execution until debugger is attached
...
```
### `breakpoint()` function
In python >= 3.7, `ptvsd` supports the `breakpoint()` function. Use `break_into_debugger()` function for similar behavior and compatibility with older versions of python (2.7 and >= 3.4). These functions will block only if the debugger is attached.
In Python 3.7 and above, `ptvsd` supports the standard `breakpoint()` function. Use `ptvsd.break_into_debugger()` function for similar behavior and compatibility with older versions of Python (3.6 and below). If the debugger is attached when either of these functions are invoked, it will pause execution on the calling line, as if it had a breakpoint set. If there's no debugger attached, the functions do nothing, and code continues to execute normally.
```python
import ptvsd
ptvsd.enable_attach()
while True:
# your code
breakpoint() # ptvsd.break_into_debugger()
# your code
...
breakpoint() # or ptvsd.break_into_debugger() on <3.7
...
```
## Custom Protocol arguments
### Launch request arguments
```js
```json5
{
"debugOptions": [
"RedirectOutput", // Whether to redirect stdout and stderr (see pydevd_comm.CMD_REDIRECT_OUTPUT)
@ -86,7 +85,7 @@ while True:
```
### Attach request arguments
```js
```json5
{
"debugOptions": [
"RedirectOutput", // Whether to redirect stdout and stderr (see pydevd_comm.CMD_REDIRECT_OUTPUT)