How to configure nvim-dap-python to pass a different working directory

[robertsawko]

Hello,

Sorry, I am still quite new to DAP. I am using nvim-dap-python and debugpy for a small Python project and would like to use a different working directory. Currently, it seems it's picking the directory of the file I am executing, but I want to use to use the root of the repo. I've looked into help and there's an item there:

DebugpyLaunchConfig                             *dap-python.DebugpyLaunchConfig*
    : DebugpyConfig

    Fields:  
        {module}       (string|nil)      Name of the module to debug
        {program}      (string|nil)      Absolute path to the program
        {code}         (string|nil)      Code to execute in string form
        {python}       (string[]|nil)    Path to python executable and interpreter arguments
        {args}         (string[]|nil)    Command line arguments passed to the program
        {console}      (DebugpyConsole)  See |dap-python.DebugpyConsole|
        {cwd}          (string|nil)      Absolute path to the working directory of the program being debugged.
        {env}          (table|nil)       Environment variables defined as key value pair
        {stopOnEntry}  (boolean|nil)     Stop at first line of user code.

But I don't know how to call it. Please let me know.

[doronbehar]

I am too confused about this - it seems like a "skeleton" for a configuration you can pass to dap.run. Also, git grep DebugpyLaunchConfig inside dap-python repository gives only comments and docs, so perhaps this should be further investigated in dap-python. The following works for me though:

However, if you simply have some dap.configurations set in your ~/.config/nvim, you can simply add the cwd key to one of them. Something like:

dap.configurations = {
	python = {
		{
			type = 'python';
			request = 'launch';
			name = "Launch file";
			program = "${file}";
			pythonPath = 'python';
			cwd = "/"
		}
	}
}

I too personally use mostly debugpy for simple Python scripts, and the complexity of these configurations has made me write the following configuration:

vim.api.nvim_create_user_command("RunScriptWithArgs", function(t)
	-- :help nvim_create_user_command
	args = vim.split(vim.fn.expand(t.args), '\n')
	approval = vim.fn.confirm(
		"Will try to run:\n    " ..
		vim.bo.filetype .. " " ..
		vim.fn.expand('%') .. " " ..
		t.args .. "\n\n" ..
		"Do you approve? ",
		"&Yes\n&No", 1
	)
	if approval == 1 then
		dap.run({
			type = vim.bo.filetype,
			request = 'launch',
			name = 'Launch file with custom arguments (adhoc)',
			program = '${file}',
			args = args,
		})
	end
end, {
	complete = 'file',
	nargs = '*'
})
vim.keymap.set('n', '<leader>R', ":RunScriptWithArgs ")

You can adapt the above to make the :RunScriptWithArgs command also ask via vim.fn.input for a certain cwd or alike. The above snippet is also documented in the WiKi.

[robertsawko]

Thanks for this! I actually stopped using nvim-dap-python, as the wiki example was sufficient for what I needed. I currently use the following .nvimrc that sits at the root directory of my project:

lua << EOF
local dap = require('dap')
dap.adapters.python = {
  type = 'executable';
  command = os.getenv("VIRTUAL_ENV") .. "/bin/python";
  args = { '-m', 'debugpy.adapter' };
}


dap.configurations.python = {
  {
    -- The first three options are required by nvim-dap
    type = 'python'; -- the type here established the link to the adapter definition: `dap.adapters.python`
    request = 'launch';
    name = "Launch file";
    cwd = "/path/to/repository/root/dir";  --python is executed from this directory

    program = "${file}"; -- This configuration will launch the current file if used.
    pythonPath = function()
      -- debugpy supports launching an application with a different interpreter then the one used to launch debugpy itself.
      -- The code below looks for a `venv` or `.venv` folder in the current directly and uses the python within.
      -- You could adapt this - to for example use the `VIRTUAL_ENV` environment variable.
      local cwd = vim.fn.getcwd()
      if vim.fn.executable(cwd .. '/venv/bin/python') == 1 then
        return cwd .. '/venv/bin/python'
      elseif vim.fn.executable(cwd .. '/.venv/bin/python') == 1 then
        return cwd .. '/.venv/bin/python'
      else
        return '/usr/bin/python'
      end
    end;
  },
}
EOF

This appears to be doing what I want, but I will review your suggestion and see how much I can incorporate.

The interface is certainly very configurable.