Fix incorrect sys.argv[0] path when calling project scripts

[wagnerluis1982]

Pull Request Check List

Resolves: #965
Closes: #1001

• Added tests for changed code.
• Updated documentation for changed code.

This PR supersedes PR #1001. I am reusing the code with the PR author's blessing, @chdsbd (see #1001 (comment)). The work I did here is the following:

1. I rebased the original code against the latest master and resolved the conflicts.
2. I handled the request for change by @finswimmer (see fix: RunCommand calling scripts with incorrect executable path #1001 (review))
3. I rewrote the test to use a real pyproject.toml and added a second test case

---

Description copied from PR #1001:

Calling sys.argv should run the same program as the currently running program. To make calling Poetry scripts through RunCommand match this behavior, we must set sys.argv[0] to be the full path of the executable.

This change makes the behavior of calling a script through poetry run the same as calling a script directly from the .venv/bin.

[wagnerluis1982]

Test on Windows is tricky 😅

[wagnerluis1982]

@radoering I didn't proper answered you regarding the script_dirs:

On this PR, I am not concerned about locations. I rely locations to Env._bin method (that I turned public and renamed to Env.get_bin_path).

But checking the underlying implementation of the turned-public method, it makes use of Env._bin_dir not Env.script_dirs.

[radoering]

I still think script_dirs is more correct. I suppose it may be possible that _bin_dir is read-only and scripts are installed in another directory. By the way, Env._bin/Env.get_bin_path does not work for Windows because scripts are not installed as ".exe" but ".cmd". I adapted the test so that a real script is installed by poetry to avoid making false assumptions.

#6971 assumes the script is always installed to the bin/Scripts folder, which will cause an issue if you add an entry to [tool.poetry.scripts] after you run poetry install.

This is very valuable input. With that information I'm quite confident we can just iterate over script_dirs and if we don't find the script it should be fine to keep argv0 as is.

Please take a look at my changes and let me know if you have any concerns.

[wagnerluis1982]

Hi @radoering, thank you for the update.

Regarding script_dirs I am still unsure about it. From what I can see in the code script_dirs[0] is always the target folder for installed scripts.

It seems to me you're trying to solve the generic case, i.e. run any command, but run_script method is used only for scripts in the [tool.poetry.scripts].

My reasoning is the following: in the RunCommand.handle there is a condition (lines 27, 28) which uses run_script when the script exists in the [tool.poetry.scripts], otherwise calls self.env.execute without any preprocessing.

poetry/src/poetry/console/commands/run.py

Lines 22 to 34 in ed5441f

	def handle(self) -> int:
	args = self.argument("args")
	script = args[0]
	scripts = self.poetry.local_config.get("scripts")
	if scripts and script in scripts:
	return self.run_script(scripts[script], args)
	try:
	return self.env.execute(*args)
	except FileNotFoundError:
	self.line_error(f"<error>Command not found: <c1>{script}</c1></error>")
	return 1

[radoering]

The root project is built/installed here:

poetry/src/poetry/console/commands/install.py

Line 182 in ed5441f

builder.build()

And here you can see that script_dirs is searched for a writable directory to install the scripts:

poetry/src/poetry/masonry/builders/editable.py

Lines 160 to 172 in ed5441f

	def _add_scripts(self) -> list[Path]:
	added = []
	entry_points = self.convert_entry_points()
	for scripts_path in self._env.script_dirs:
	if is_dir_writable(path=scripts_path, create=True):
	break
	else:
	self._io.write_error_line(
	" - Failed to find a suitable script installation directory for"
	f" {self._poetry.file.parent}"
	)
	return []

[wagnerluis1982]

Makes sense. I'm convinced!

PS: I don't quite understand how script_path.exists() is working on Windows, given you're running without extension in the tests 😱

[radoering]

It's a bit weird. 😄 There are two files on Windows. One without extension and one with ".cmd". And even when executing without an extension the ".cmd" seems to be used. Strictly speaking, we had to check for the existence of the ".cmd", but since we are creating both files, it's probably not that relevant. I assume we could also add the ".cmd" for argv0. Might be cleaner. 🤷

poetry/src/poetry/masonry/builders/editable.py

Lines 184 to 211 in ed5441f

	with script_file.open("w", encoding="utf-8") as f:
	f.write(
	decode(
	SCRIPT_TEMPLATE.format(
	python=self._env.python,
	module=module,
	callable_holder=callable_holder,
	callable_=callable_,
	)
	)
	)
	script_file.chmod(0o755)
	added.append(script_file)
	if WINDOWS:
	cmd_script = script_file.with_suffix(".cmd")
	cmd = WINDOWS_CMD_TEMPLATE.format(python=self._env.python, script=name)
	self._debug(
	f" - Adding the <c2>{cmd_script.name}</c2> script wrapper to"
	f" <b>{scripts_path}</b>"
	)
	with cmd_script.open("w", encoding="utf-8") as f:
	f.write(decode(cmd))
	added.append(cmd_script)

[wagnerluis1982]

I pushed a commit to include .cmd on Windows (tests are passing).

Also, I added a few minor contextual comments to the code.

Everything fixed or no longer relevant.

[wagnerluis1982]

I understand you want to use `sys.argv[0]` to make a self call to the script. Now I wonder how useful would be a `sys.argv[0]` pointing to a imaginary non-existing location (which would be the case when the script is not installed).

…

On Fri, 17 Feb 2023, 16:11 David Lord, ***@***.***> wrote: ***@***.**** commented on this pull request. This is incorrect. sys.argv[0] should be the absolute path to the imported file, regardless of installation status..

[davidism]

It should probably be ["-c"] instead of the name of the Poetry script if it's not installed. That mirrors Python's sys.argv behavior for what Poetry is actually doing internally. Or Poetry could set it to [imported_module.__file__] regardless of if the script is installed or not. No tool inspecting sys.argv would know what to do with the name on its own.

sys.orig_argv can be used (and shouldn't be modified by Poetry) to get the original command line that would produce the same execution.

[wagnerluis1982]

@davidism I think is sort of pointless to discuss this here, in a closed PR. Better to focus the discussion on the open issue #7528

[github-actions]

This pull request has been automatically locked since there has not been any recent activity after it was closed. Please open a new issue for related bugs.