Calling a pipx installed python wrapper "executable" fails unless I use the absolute path?

[ptr727]

I am trying to call whisper-ctranslate2 that I installed on Debian 13 using pipx, and I get an exception that the exe was not found.

I install like this:

sudo apt install ffmpeg python3 python3-pip python3-venv build-essential pipx
pipx ensurepath
pipx install whisper-ctranslate2
pipx list
which whisper-ctranslate2
command -v whisper-ctranslate2
whisper-ctranslate2 --help

This works fine, and when I SSH remove VSCode to the machine it also works fine when called from the VSCode terminal:

$ which whisper-ctranslate2
/home/pieter/.local/bin/whisper-ctranslate2

$ command -v whisper-ctranslate2
/home/pieter/.local/bin/whisper-ctranslate2

$ whisper-ctranslate2 --help
usage: whisper-ctranslate2 [-h]

And the "executable" /home/pieter/.local/bin/whisper-ctranslate2 is a shell redirection:

#!/home/pieter/.local/share/pipx/venvs/whisper-ctranslate2/bin/python
import sys
from whisper_ctranslate2.whisper_ctranslate2 import main
if __name__ == '__main__':
    if sys.argv[0].endswith('.exe'):
        sys.argv[0] = sys.argv[0][:-4]
    sys.exit(main())

When I call CliWrap with just the whisper-translate2, I get:

14:17:52 [ERR] <1> "ExecuteAsync"
System.ComponentModel.Win32Exception (2): Failed to start a process with file path 'whisper-ctranslate2'. Target file or working directory doesn't exist, the provided credentials are invalid, or the resource policy cannot be set due to insufficient permissions. See the inner exception for more information. ---> System.ComponentModel.Win32Exception (2): An error occurred trying to start process 'whisper-ctranslate2' with working directory '/home/pieter/AudioCleaner/AudioCleaner/bin/Debug/net10.0'. No such file or directory
   at System.Diagnostics.Process.ForkAndExecProcess(ProcessStartInfo startInfo, String resolvedFilename, String[] argv, String[] envp, String cwd, Boolean setCredentials, UInt32 userId, UInt32 groupId, UInt32[] groups, Int32& stdinFd, Int32& stdoutFd, Int32& stderrFd, Boolean usesTerminal, Boolean throwOnNoExec)
   at System.Diagnostics.Process.StartCore(ProcessStartInfo startInfo)
   at CliWrap.Utils.ProcessEx.Start(Action`1 configureProcess) in /_/CliWrap/Utils/ProcessEx.cs:line 69
   at CliWrap.Utils.ProcessEx.Start(Action`1 configureProcess) in /_/CliWrap/Utils/ProcessEx.cs:line 79
   at CliWrap.Command.ExecuteAsync(Action`1 configureStartInfo, Action`1 configureProcess, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Command.Execution.cs:line 322
   at CliWrap.Command.ExecuteAsync(CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Command.Execution.cs:line 378
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken forcefulCancellationToken, CancellationToken gracefulCancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 44
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding standardOutputEncoding, Encoding standardErrorEncoding, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 95
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, Encoding encoding, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 116
   at CliWrap.Buffered.BufferedCommandExtensions.ExecuteBufferedAsync(Command command, CancellationToken cancellationToken) in /_/CliWrap/Buffered/BufferedCommandExtensions.cs:line 132
   at Whisper.Version(CancellationToken cancellationToken) in /home/pieter/AudioCleaner/AudioCleaner/Whisper.cs:line 56
   at AudioCleaner.Program.ExecuteAsync() in /home/pieter/AudioCleaner/AudioCleaner/Program.cs:line 43
14:17:52 [FTL] <1> Exception during processing.

To fix it I must explicitly call the absolute path:

    public static async Task<int> Version(CancellationToken cancellationToken)
    {
        // command -v whisper-ctranslate2
        // /home/pieter/.local/bin/whisper-ctranslate2

        string home = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
        string whisper = Path.Combine(home, ".local", "bin", "whisper-ctranslate2");
        // string whisper = "whisper-ctranslate2";
        Log.Debug("Whisper path: {Whisper}", whisper);

        BufferedCommandResult result = await Cli.Wrap(whisper)
            .WithArguments(args => args.Add("--version"))
            .ExecuteBufferedAsync(cancellationToken);
        return result.ExitCode;
    }

This makes it machine and user specific, how can I call the "executable" in the same way the shell would call it without needing to create an absolute path?

[Tyrrrz]

Does the regular Process class show similar behavior?

I've previously introduced this file path resolving strategy, but thought it was only needed on Windows:

CliWrap/CliWrap/Command.Execution.cs

Lines 17 to 75 in fdf4bce

	// System.Diagnostics.Process already resolves the full path by itself, but it naively assumes that the file
	// is an executable if the extension is omitted. On Windows, BAT and CMD files may also be valid targets.
	// In practice, it means that Process.Start("foo") will work if it's an EXE file, but will fail if it's a
	// BAT or CMD file, even if it's on the PATH. If the extension is specified, it will work in both cases.
	private string GetOptimallyQualifiedTargetFilePath()
	{
	// Currently, we only need this workaround for script files on Windows, so short-circuit
	// if we are on a different platform.
	if (!OperatingSystem.IsWindows())
	{
	return TargetFilePath;
	}
	// Don't do anything for fully qualified paths or paths that already have an extension specified.
	// System.Diagnostics.Process knows how to handle those without our help.
	// Note that IsPathRooted(...) doesn't check if the path is absolute, as it also returns true for
	// strings like 'c:foo.txt' (which is relative to the current directory on drive C), but it's good
	// enough for our purposes and the alternative is only available on .NET Standard 2.1+.
	if (
	Path.IsPathRooted(TargetFilePath)
	|| !string.IsNullOrWhiteSpace(Path.GetExtension(TargetFilePath))
	)
	{
	return TargetFilePath;
	}
	static IEnumerable<string> GetProbeDirectoryPaths()
	{
	// Implementation reference:
	// https://github.com/dotnet/runtime/blob/9a50493f9f1125fda5e2212b9d6718bc7cdbc5c0/src/libraries/System.Diagnostics.Process/src/System/Diagnostics/Process.Unix.cs#L686-L728
	// MIT License, .NET Foundation
	// Executable directory
	if (!string.IsNullOrWhiteSpace(Environment.ProcessPath))
	{
	var processDirPath = Path.GetDirectoryName(Environment.ProcessPath);
	if (!string.IsNullOrWhiteSpace(processDirPath))
	yield return processDirPath;
	}
	// Working directory
	yield return Directory.GetCurrentDirectory();
	// Directories on the PATH
	if (Environment.GetEnvironmentVariable("PATH")?.Split(Path.PathSeparator) is { } paths)
	{
	foreach (var path in paths)
	yield return path;
	}
	}
	return (
	from probeDirPath in GetProbeDirectoryPaths()
	where Directory.Exists(probeDirPath)
	select Path.Combine(probeDirPath, TargetFilePath) into baseFilePath
	from extension in new[] { "exe", "cmd", "bat" }
	select Path.ChangeExtension(baseFilePath, extension)
	).FirstOrDefault(File.Exists) ?? TargetFilePath;
	}

[ptr727]

I'll test with native Process when I get a moment.