env_logger::init();

// NOTE: This is not a WASI convention. But it will be convenient since POSIX shell always defines it.

#[cfg(target_os = "wasi")]

{

if let Ok(pwd) = env::var("PWD") {

let _ = env::set_current_dir(pwd);

};

}

let (settings, run_mode) = match parse_opts() {

Ok(x) => x,

Err(e) => {

println!("{e}");

return ExitCode::FAILURE;

}

};

// don't translate newlines (\r\n <=> \n)

#[cfg(windows)]

{

unsafe extern "C" {

fn _setmode(fd: i32, flags: i32) -> i32;

}

unsafe {

_setmode(0, libc::O_BINARY);

_setmode(1, libc::O_BINARY);

_setmode(2, libc::O_BINARY);

}

let get_getpip = rustpython_vm::py_compile!(

source = r#"\

mode = "eval"

);

eprintln!("downloading get-pip.py...");

let getpip_code = vm.run_code_obj(vm.ctx.new_code(get_getpip), vm.new_scope_with_builtins())?;

let getpip_code: rustpython_vm::builtins::PyStrRef = getpip_code

.downcast()

.expect("TextIOWrapper.read() should return str");

eprintln!("running get-pip.py...");

vm.run_string(scope, getpip_code.expect_str(), "get-pip.py".to_owned())?;

Ok(())

if !cfg!(feature = "ssl") {

return Err(vm.new_exception_msg(

vm.ctx.exceptions.system_error.to_owned(),

"install-pip requires rustpython be build with '--features=ssl'".into(),

));

}

match installer {

InstallPipMode::Ensurepip => vm.run_module("ensurepip"),

InstallPipMode::GetPip => get_pip(scope, vm),

}

// Check if path is a package/directory with __main__.py

if let Some(_importer) = get_importer(path, vm)? {

vm.insert_sys_path(vm.new_pyobj(path))?;

let runpy = vm.import("runpy", 0)?;

let run_module_as_main = runpy.get_attr("_run_module_as_main", vm)?;

run_module_as_main.call((vm::identifier!(vm, __main__).to_owned(), false), vm)?;

return Ok(());

}

// Add script directory to sys.path[0]

if !vm.state.config.settings.safe_path {

let dir = std::path::Path::new(path)

.parent()

.and_then(|p| p.to_str())

.unwrap_or("");

vm.insert_sys_path(vm.new_pyobj(dir))?;

}

#[cfg(feature = "host_env")]

{

vm.run_any_file(scope, path)

}

#[cfg(not(feature = "host_env"))]

{

// In sandbox mode, the binary reads the file and feeds source to the VM.

// The VM itself has no filesystem access.

let path = if path.is_empty() { "???" } else { path };

match std::fs::read_to_string(path) {

Ok(source) => vm.run_string(scope, &source, path.to_owned()).map(drop),

Err(err) => Err(vm.new_os_error(err.to_string())),

}

}

use rustpython_vm::builtins::PyDictRef;

use rustpython_vm::convert::TryFromObject;

let path_importer_cache = vm.sys_module.get_attr("path_importer_cache", vm)?;

let path_importer_cache = PyDictRef::try_from_object(vm, path_importer_cache)?;

if let Some(importer) = path_importer_cache.get_item_opt(path, vm)? {

return Ok(Some(importer));

}

let path_obj = vm.ctx.new_str(path);

let path_hooks = vm.sys_module.get_attr("path_hooks", vm)?;

let mut importer = None;

let path_hooks: Vec<PyObjectRef> = path_hooks.try_into_value(vm)?;

for path_hook in path_hooks {

match path_hook.call((path_obj.clone(),), vm) {

Ok(imp) => {

importer = Some(imp);

break;

}

Err(e) if e.fast_isinstance(vm.ctx.exceptions.import_error) => continue,

Err(e) => return Err(e),

}

}

Ok(if let Some(imp) = importer {

let imp = path_importer_cache.get_or_insert(vm, path_obj.into(), || imp.clone())?;

Some(imp)

} else {

None

})

#[cfg(feature = "flame-it")]

let main_guard = flame::start_guard("RustPython main");

let scope = vm.new_scope_with_main()?;

// Initialize warnings module to process sys.warnoptions

// _PyWarnings_Init()

if vm.import("warnings", 0).is_err() {

warn!("Failed to import warnings module");

}

// Import site first, before setting sys.path[0]

// This matches CPython's behavior where site.removeduppaths() runs

// before sys.path[0] is set, preventing '' from being converted to cwd

let site_result = vm.import("site", 0);

if site_result.is_err() {

warn!(

"Failed to import site, consider adding the Lib directory to your RUSTPYTHONPATH \

);

}

// _PyPathConfig_ComputeSysPath0 - set sys.path[0] after site import

if !vm.state.config.settings.safe_path {

let path0: Option<String> = match &run_mode {

RunMode::Command(_) => Some(String::new()),

RunMode::Module(_) => env::current_dir()

.ok()

.and_then(|p| p.to_str().map(|s| s.to_owned())),

RunMode::Script(_) | RunMode::InstallPip(_) => None, // handled by run_script

RunMode::Repl => Some(String::new()),

};

if let Some(path) = path0 {

vm.insert_sys_path(vm.new_pyobj(path))?;

}

}

// Enable faulthandler if -X faulthandler, PYTHONFAULTHANDLER or -X dev is set

// _PyFaulthandler_Init()

if vm.state.config.settings.faulthandler {

let _ = vm.run_simple_string("import faulthandler; faulthandler.enable()");

}

let is_repl = matches!(run_mode, RunMode::Repl);

if !vm.state.config.settings.quiet

&& (vm.state.config.settings.verbose > 0 || (is_repl && std::io::stdin().is_terminal()))

{

eprintln!(

"Welcome to the magnificent Rust Python {} interpreter \u{1f631} \u{1f596}",

env!("CARGO_PKG_VERSION")

);

eprintln!(

"RustPython {}.{}.{}",

vm::version::MAJOR,

vm::version::MINOR,

vm::version::MICRO,

);

eprintln!("Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.");

}

let res = match run_mode {

RunMode::Command(command) => {

debug!("Running command {command}");

vm.run_string(scope.clone(), &command, "<string>".to_owned())

.map(drop)

}

RunMode::Module(module) => {

debug!("Running module {module}");

vm.run_module(&module)

}

RunMode::InstallPip(installer) => install_pip(installer, scope.clone(), vm),

RunMode::Script(script_path) => {

// pymain_run_file_obj

debug!("Running script {}", &script_path);

run_file(vm, scope.clone(), &script_path)

}

RunMode::Repl => Ok(()),

};

let result = if is_repl || vm.state.config.settings.inspect {

shell::run_shell(vm, scope)

} else {

res

};

#[cfg(feature = "flame-it")]

{

main_guard.end();

if let Err(e) = write_profile(&vm.state.as_ref().config.settings) {

error!("Error writing profile information: {}", e);

}

}

result

use std::{fs, io};

enum ProfileFormat {

Html,

Text,

SpeedScope,

}

let profile_output = settings.profile_output.as_deref();

let profile_format = match settings.profile_format.as_deref() {

Some("html") => ProfileFormat::Html,

Some("text") => ProfileFormat::Text,

None if profile_output == Some("-".as_ref()) => ProfileFormat::Text,

// spell-checker:ignore speedscope

Some("speedscope") | None => ProfileFormat::SpeedScope,

Some(other) => {

error!("Unknown profile format {}", other);

// TODO: Need to change to ExitCode or Termination

std::process::exit(1);

}

};

let profile_output = profile_output.unwrap_or_else(|| match profile_format {

ProfileFormat::Html => "flame-graph.html".as_ref(),

ProfileFormat::Text => "flame.txt".as_ref(),

ProfileFormat::SpeedScope => "flamescope.json".as_ref(),

});

let profile_output: Box<dyn io::Write> = if profile_output == "-" {

Box::new(io::stdout())

} else {

Box::new(fs::File::create(profile_output)?)

};

let profile_output = io::BufWriter::new(profile_output);

match profile_format {

ProfileFormat::Html => flame::dump_html(profile_output)?,

ProfileFormat::Text => flame::dump_text_to_writer(profile_output)?,

ProfileFormat::SpeedScope => flamescope::dump(profile_output)?,

}

Ok(())

use super::*;

use rustpython_vm::Interpreter;

fn interpreter() -> Interpreter {

InterpreterBuilder::new().init_stdlib().interpreter()

}

#[test]

fn test_run_script() {

interpreter().enter(|vm| {

vm.unwrap_pyresult((|| {

let scope = vm.new_scope_with_main()?;

// test file run

run_file(vm, scope, "extra_tests/snippets/dir_main/__main__.py")?;

#[cfg(feature = "host_env")]

{

let scope = vm.new_scope_with_main()?;

// test module run (directory with __main__.py)

run_file(vm, scope, "extra_tests/snippets/dir_main")?;

}

Ok(())

})());

})

}