[NO TESTS] WIP

Author: arrdem

py/private/py_venv/entrypoint.tmpl.sh

@@ -12,4 +12,4 @@ set -o errexit -o nounset -o pipefail
 
 source "$(rlocation "{{VENV}}")"/bin/activate
 
-exec "$(rlocation "{{VENV}}")"/bin/python {{INTERPRETER_FLAGS}} "$@"
+exec "$(rlocation "{{VENV}}")"/bin/python3 {{INTERPRETER_FLAGS}} "$@"

py/tests/py-venv-standalone-interpreter/test.sh

@@ -4,7 +4,7 @@ set -ex
 
 ROOT="$(dirname $0)"
 
-"$ROOT"/.ex/bin/python --help >/dev/null 2>&1
+"$ROOT"/.ex/bin/python --help
 
 if [ "Hello, world!" != "$($ROOT/.ex/bin/python -c 'from ex import hello; print(hello())')" ]; then
     exit 1

py/tools/venv_shim/src/main.rs

@@ -225,7 +225,7 @@ fn find_actual_interpreter(executable: impl AsRef<Path>, cfg: &PyCfg) -> Result<
 
 fn main() -> Result<()> {
     let all_args: Vec<_> = env::args().collect();
-    let Some((exec_name, exec_args)) = all_args.split_first() else {
+    let Some((exec_name, _exec_args)) = all_args.split_first() else {
         miette::bail!("could not discover an execution command-line");
     };
 
@@ -324,7 +324,7 @@ fn main() -> Result<()> {
     eprintln!("[aspect] {:?}", venv_config);
 
     // The logical path of the interpreter
-    let venv_interpreter = venv_root.join("bin/python3");
+    let venv_interpreter = venv_root.join("bin").join(executable.file_name().unwrap());
     #[cfg(feature = "debug")]
     eprintln!("[aspect] {:?}", venv_interpreter);
 
@@ -342,6 +342,8 @@ fn main() -> Result<()> {
     // Lie about the value of argv0 to hoodwink the interpreter as to its
     // location on Linux-based platforms.
     reexec_args.remove(0);
+
+    #[cfg(feature = "debug")]
     eprintln!("Reexec args {:?}", reexec_args);
 
     let mut cmd = Command::new(&actual_interpreter);
@@ -401,8 +403,7 @@ fn main() -> Result<()> {
     home.to_str().unwrap().hash(&mut hasher);
     cmd.env("ASPECT_PY_VALIDITY", format!("{}", hasher.finish()));
 
-    // 1
-
+    #[cfg(feature = "debug")]
     eprintln!("Punting to {:?}", cmd);
 
     // And punt

py/tools/venv_shim/src/pyargs.rs

@@ -7,48 +7,8 @@ fn build_parser() -> Command {
         .disable_help_flag(true)
         .dont_delimit_trailing_values(true)
         .allow_hyphen_values(true)
-        .arg(
-            Arg::new("bytes_warning_level")
-                .short('b')
-                .action(ArgAction::Count),
-        )
-        .arg(
-            Arg::new("dont_write_bytecode")
-                .short('B')
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("command")
-                .short('c')
-                .value_name("cmd")
-                .conflicts_with("module"),
-        )
-        .arg(
-            Arg::new("debug_parser")
-                .short('d')
-                .action(ArgAction::SetTrue),
-        )
         .arg(Arg::new("ignore_env").short('E').action(ArgAction::SetTrue))
-        .arg(
-            Arg::new("help")
-                .short('h')
-                .long("help")
-                .action(ArgAction::Help),
-        )
-        .arg(Arg::new("inspect").short('i').action(ArgAction::SetTrue))
         .arg(Arg::new("isolate").short('I').action(ArgAction::SetTrue))
-        .arg(
-            Arg::new("module")
-                .short('m')
-                .value_name("mod")
-                .conflicts_with("command"),
-        )
-        .arg(
-            Arg::new("optimize_level")
-                .short('O')
-                .action(ArgAction::Count),
-        )
-        .arg(Arg::new("quiet").short('q').action(ArgAction::SetTrue))
         .arg(
             Arg::new("no_user_site")
                 .short('s')
@@ -59,31 +19,6 @@ fn build_parser() -> Command {
                 .short('S')
                 .action(ArgAction::SetTrue),
         )
-        .arg(Arg::new("unbuffered").short('u').action(ArgAction::SetTrue))
-        .arg(Arg::new("verbosity").short('v').action(ArgAction::Count))
-        .arg(
-            Arg::new("version")
-                .short('V')
-                .long("version")
-                .action(ArgAction::Count),
-        )
-        .arg(
-            Arg::new("warnings")
-                .short('W')
-                .value_name("arg")
-                .action(ArgAction::Append),
-        )
-        .arg(
-            Arg::new("skip_first_line")
-                .short('x')
-                .action(ArgAction::SetTrue),
-        )
-        .arg(
-            Arg::new("extended_options")
-                .short('X')
-                .value_name("opt")
-                .action(ArgAction::Append),
-        )
         .arg(
             arg!(<args> ...)
                 .trailing_var_arg(true)
@@ -93,66 +28,23 @@ fn build_parser() -> Command {
 }
 
 pub struct ArgState {
-    pub bytes_warning_level: u8,
-    pub dont_write_bytecode: bool,
-    pub command: Option<String>,
-    pub debug_parser: bool,
     pub ignore_env: bool,
-    pub help: bool,
-    pub inspect: bool,
     pub isolate: bool,
-    pub module: Option<String>,
-    pub optimize_level: u8,
-    pub quiet: bool,
-    pub no_user_site: bool,
     pub no_import_site: bool,
-    pub unbuffered: bool,
-    pub verbosity: u8,
-    pub version: u8,
-    pub warnings: Vec<String>,
-    pub skip_first_line: bool,
-    pub extended_options: Vec<String>,
+    pub no_user_site: bool,
     pub remaining_args: Vec<String>,
 }
 
 fn extract_state(matches: &ArgMatches) -> ArgState {
     ArgState {
-        bytes_warning_level: *matches.get_one::<u8>("bytes_warning_level").unwrap_or(&0),
-        dont_write_bytecode: *matches
-            .get_one::<bool>("dont_write_bytecode")
-            .unwrap_or(&false),
-        command: matches.get_one::<String>("command").cloned(),
-        debug_parser: *matches.get_one::<bool>("debug_parser").unwrap_or(&false),
         // E and I are crucial for transformation
         ignore_env: *matches.get_one::<bool>("ignore_env").unwrap_or(&false),
         isolate: *matches.get_one::<bool>("isolate").unwrap_or(&false),
 
-        help: *matches.get_one::<bool>("help").unwrap_or(&false),
-        inspect: *matches.get_one::<bool>("inspect").unwrap_or(&false),
-        module: matches.get_one::<String>("module").cloned(),
-        optimize_level: *matches.get_one::<u8>("optimize_level").unwrap_or(&0),
-        quiet: *matches.get_one::<bool>("quiet").unwrap_or(&false),
-
         // s is crucial for transformation
         no_user_site: *matches.get_one::<bool>("no_user_site").unwrap_or(&false),
 
         no_import_site: *matches.get_one::<bool>("no_import_site").unwrap_or(&false),
-        unbuffered: *matches.get_one::<bool>("unbuffered").unwrap_or(&false),
-        verbosity: *matches.get_one::<u8>("verbosity").unwrap_or(&0),
-        version: *matches.get_one::<u8>("version").unwrap_or(&0),
-        skip_first_line: *matches.get_one::<bool>("skip_first_line").unwrap_or(&false),
-
-        // For multiple values, clone the Vec
-        warnings: matches
-            .get_many::<String>("warnings")
-            .unwrap_or_default()
-            .cloned()
-            .collect(),
-        extended_options: matches
-            .get_many::<String>("extended_options")
-            .unwrap_or_default()
-            .cloned()
-            .collect(),
 
         remaining_args: matches
             .get_many::<String>("args")
@@ -179,58 +71,16 @@ pub fn reparse_args(original_argv: &Vec<&str>) -> Result<Vec<String>> {
     // Retain the original argv binary
     argv.push(original_argv[0].to_string());
 
-    if parsed_args.bytes_warning_level == 1 {
-        argv.push(String::from("-b"));
-    } else if parsed_args.bytes_warning_level >= 2 {
-        argv.push(String::from("-bb"));
-    }
-
-    push_flag(&mut argv, 'B', parsed_args.dont_write_bytecode);
-    push_flag(&mut argv, 'd', parsed_args.debug_parser);
-    push_flag(&mut argv, 'h', parsed_args.help);
-    push_flag(&mut argv, 'i', parsed_args.inspect);
-
     // -I replacement logic: -I is never pushed, its effects (-E and -s) are handled separately.
     // -E removal: -E is never pushd
     // -s inclusion logic: we ALWAYS push -s
-    push_flag(&mut argv, 's', true);
+    push_flag(
+        &mut argv,
+        's',
+        parsed_args.no_user_site | parsed_args.isolate,
+    );
 
     push_flag(&mut argv, 'S', parsed_args.no_import_site);
-    push_flag(&mut argv, 'u', parsed_args.unbuffered);
-    push_flag(&mut argv, 'q', parsed_args.quiet);
-    push_flag(&mut argv, 'x', parsed_args.skip_first_line);
-
-    if let Some(cmd) = &parsed_args.command {
-        argv.push(String::from("-c"));
-        argv.push(cmd.clone());
-    }
-    if let Some(module) = &parsed_args.module {
-        argv.push(String::from("-m"));
-        argv.push(module.clone());
-    }
-    if parsed_args.optimize_level == 1 {
-        argv.push(String::from("-O"));
-    } else if parsed_args.optimize_level >= 2 {
-        argv.push(String::from("-OO"));
-    }
-
-    for _ in 0..parsed_args.verbosity {
-        argv.push(String::from("-v"));
-    }
-    if parsed_args.version == 1 {
-        argv.push(String::from("-V"));
-    } else if parsed_args.version >= 2 {
-        argv.push(String::from("-VV"));
-    }
-
-    for warning in &parsed_args.warnings {
-        argv.push(String::from("-W"));
-        argv.push(warning.clone());
-    }
-    for opt in &parsed_args.extended_options {
-        argv.push(String::from("-X"));
-        argv.push(opt.clone());
-    }
 
     argv.extend(parsed_args.remaining_args.iter().cloned());
 
@@ -315,21 +165,11 @@ mod test {
         assert!(expected == reparsed.unwrap(), "Didn't translate -I to -s");
     }
 
-    #[test]
-    fn basic_add_s() {
-        // We expect to ADD the -s flag
-        let orig = vec!["python", "-c", "exit(0)", "arg1"];
-        let expected = vec!["python", "-s", "-c", "exit(0)", "arg1"];
-        let reparsed = reparse_args(&orig);
-        assert!(reparsed.is_ok(), "Args failed to parse {:?}", reparsed);
-        assert!(expected == reparsed.unwrap(), "Didn't add -s");
-    }
-
     #[test]
     fn basic_m_preserved() {
         // We expect to ADD the -s flag
         let orig = vec!["python", "-m", "build", "--unknown", "arg1"];
-        let expected = vec!["python", "-s", "-m", "build", "--unknown", "arg1"];
+        let expected = vec!["python", "-m", "build", "--unknown", "arg1"];
         let reparsed = reparse_args(&orig);
         assert!(reparsed.is_ok(), "Args failed to parse {:?}", reparsed);
         assert!(expected == reparsed.unwrap(), "Didn't add -s");
@@ -345,7 +185,6 @@ mod test {
         ];
         let expected =  vec![
             "python3",
-            "-s",
             "uv/private/sdist_build/build_helper.py",
             "bazel-out/darwin_arm64-fastbuild/bin/external/+uv+sbuild__pypi__default__bravado_core/src",
             "bazel-out/darwin_arm64-fastbuild/bin/external/+uv+sbuild__pypi__default__bravado_core/build"
@@ -373,7 +212,6 @@ mod test {
         ];
         let expected =  vec![
             "python3",
-            "-s",
             "-m",
             "build",
             "--no-isolation",

uv/private/sdist_build/build_helper.py

@@ -3,7 +3,7 @@
 from argparse import ArgumentParser
 import shutil
 import sys
-from os import getenv, listdir, path
+from os import getenv, listdir, path, execv
 from subprocess import check_call, CalledProcessError
 
 # Under Bazel, the source dir of a sdist to build is immutable. `build` and
@@ -27,19 +27,12 @@
 shutil.copystat = lambda x, y, **k: None
 shutil.copytree(opts.srcdir, t, dirs_exist_ok=True)
 
-outdir = path.abspath(opts.outdir)
-args = [
-    sys.executable,
+for e in sys.path:
+    print(" -", e, file=sys.stderr)
+    
+execv(sys.executable, [
     "-m", "build",
     "--wheel",
     "--no-isolation",
-    "--outdir", outdir,
-]
-print(args, file=sys.stderr)
-
-try:
-    check_call(args, cwd=t)
-except CalledProcessError:
-    exit(1)
-
-print(listdir(outdir), file=sys.stderr)
+    "--outdir", opts.outdir,
+])