Struct VenvArgs 

pub struct VenvArgs {

    pub python: Option<Maybe<String>>,
    pub system: bool,
    pub no_system: bool,
    pub no_project: bool,
    pub seed: bool,
    pub clear: bool,
    pub no_clear: bool,
    pub allow_existing: bool,
    pub path: Option<PathBuf>,
    pub prompt: Option<String>,
    pub system_site_packages: bool,
    pub relocatable: bool,
    pub index_args: IndexArgs,
    pub index_strategy: Option<IndexStrategy>,
    pub keyring_provider: Option<KeyringProviderType>,
    pub exclude_newer: Option<ExcludeNewerValue>,
    pub exclude_newer_package: Option<Vec<ExcludeNewerPackageEntry>>,
    pub link_mode: Option<LinkMode>,
    pub refresh: RefreshArgs,
    pub compat_args: VenvCompatArgs,
}

Fields

python: Option<Maybe<String>>

The Python interpreter to use for the virtual environment.

During virtual environment creation, uv will not look for Python interpreters in virtual environments.

See uv help python for details on Python discovery and supported request formats.

system: bool

Ignore virtual environments when searching for the Python interpreter.

This is the default behavior and has no effect.

no_system: bool

This flag is included for compatibility only, it has no effect.

uv will never search for interpreters in virtual environments when creating a virtual environment.

no_project: bool

Avoid discovering a project or workspace.

By default, uv searches for projects in the current directory or any parent directory to determine the default path of the virtual environment and check for Python version constraints, if any.

seed: bool

Install seed packages (one or more of: pip, setuptools, and wheel) into the virtual environment.

Note that setuptools and wheel are not included in Python 3.12+ environments.

clear: bool

Remove any existing files or directories at the target path.

By default, uv venv will exit with an error if the given path is non-empty. The --clear option will instead clear a non-empty path before creating a new virtual environment.

no_clear: bool

Fail without prompting if any existing files or directories are present at the target path.

By default, when a TTY is available, uv venv will prompt to clear a non-empty directory. When --no-clear is used, the command will exit with an error instead of prompting.

allow_existing: bool

Preserve any existing files or directories at the target path.

By default, uv venv will exit with an error if the given path is non-empty. The --allow-existing option will instead write to the given path, regardless of its contents, and without clearing it beforehand.

WARNING: This option can lead to unexpected behavior if the existing virtual environment and the newly-created virtual environment are linked to different Python interpreters.

path: Option<PathBuf>

The path to the virtual environment to create.

Default to .venv in the working directory.

Relative paths are resolved relative to the working directory.

prompt: Option<String>

Provide an alternative prompt prefix for the virtual environment.

By default, the prompt is dependent on whether a path was provided to uv venv. If provided (e.g, uv venv project), the prompt is set to the directory name. If not provided (uv venv), the prompt is set to the current directory’s name.

If “.” is provided, the current directory name will be used regardless of whether a path was provided to uv venv.

system_site_packages: bool

Give the virtual environment access to the system site packages directory.

Unlike pip, when a virtual environment is created with --system-site-packages, uv will not take system site packages into account when running commands like uv pip list or uv pip install. The --system-site-packages flag will provide the virtual environment with access to the system site packages directory at runtime, but will not affect the behavior of uv commands.

relocatable: bool

Make the virtual environment relocatable.

A relocatable virtual environment can be moved around and redistributed without invalidating its associated entrypoint and activation scripts.

Note that this can only be guaranteed for standard console_scripts and gui_scripts. Other scripts may be adjusted if they ship with a generic #!python[w] shebang, and binaries are left as-is.

As a result of making the environment relocatable (by way of writing relative, rather than absolute paths), the entrypoints and scripts themselves will not be relocatable. In other words, copying those entrypoints and scripts to a location outside the environment will not work, as they reference paths relative to the environment itself.

index_args: IndexArgs

index_strategy: Option<IndexStrategy>

The strategy to use when resolving against multiple index URLs.

By default, uv will stop at the first index on which a given package is available, and limit resolutions to those present on that first index (first-index). This prevents “dependency confusion” attacks, whereby an attacker can upload a malicious package under the same name to an alternate index.

keyring_provider: Option<KeyringProviderType>

Attempt to use keyring for authentication for index URLs.

At present, only --keyring-provider subprocess is supported, which configures uv to use the keyring CLI to handle authentication.

Defaults to disabled.

exclude_newer: Option<ExcludeNewerValue>

Limit candidate packages to those that were uploaded prior to the given date.

Accepts RFC 3339 timestamps (e.g., 2006-12-02T02:07:43Z), local dates in the same format (e.g., 2006-12-02) resolved based on your system’s configured time zone, a “friendly” duration (e.g., 24 hours, 1 week, 30 days), or an ISO 8601 duration (e.g., PT24H, P7D, P30D).

Durations do not respect semantics of the local time zone and are always resolved to a fixed number of seconds assuming that a day is 24 hours (e.g., DST transitions are ignored). Calendar units such as months and years are not allowed.

exclude_newer_package: Option<Vec<ExcludeNewerPackageEntry>>

Limit candidate packages for a specific package to those that were uploaded prior to the given date.

Accepts package-date pairs in the format PACKAGE=DATE, where DATE is an RFC 3339 timestamp (e.g., 2006-12-02T02:07:43Z), a local date in the same format (e.g., 2006-12-02) resolved based on your system’s configured time zone, a “friendly” duration (e.g., 24 hours, 1 week, 30 days), or a ISO 8601 duration (e.g., PT24H, P7D, P30D).

Durations do not respect semantics of the local time zone and are always resolved to a fixed number of seconds assuming that a day is 24 hours (e.g., DST transitions are ignored). Calendar units such as months and years are not allowed.

Can be provided multiple times for different packages.

link_mode: Option<LinkMode>

The method to use when installing packages from the global cache.

This option is only used for installing seed packages.

Defaults to clone (also known as Copy-on-Write) on macOS, and hardlink on Linux and Windows.

WARNING: The use of symlink link mode is discouraged, as they create tight coupling between the cache and the target environment. For example, clearing the cache (uv cache clean) will break all installed packages by way of removing the underlying source files. Use symlinks with caution.

refresh: RefreshArgs

compat_args: VenvCompatArgs

Trait Implementations

impl Args for VenvArgs

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl FromArgMatches for VenvArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.