Struct AddArgs 

pub struct AddArgs {

    pub packages: Vec<String>,
    pub requirements: Vec<PathBuf>,
    pub constraints: Vec<Maybe<PathBuf>>,
    pub marker: Option<MarkerTree>,
    pub dev: bool,
    pub optional: Option<ExtraName>,
    pub group: Option<GroupName>,
    pub editable: bool,
    pub no_editable: bool,
    pub raw: bool,
    pub bounds: Option<AddBoundsKind>,
    pub rev: Option<String>,
    pub tag: Option<String>,
    pub branch: Option<String>,
    pub lfs: bool,
    pub extra: Option<Vec<ExtraName>>,
    pub no_sync: bool,
    pub locked: bool,
    pub frozen: bool,
    pub active: bool,
    pub no_active: bool,
    pub installer: ResolverInstallerArgs,
    pub build: BuildOptionsArgs,
    pub refresh: RefreshArgs,
    pub package: Option<PackageName>,
    pub script: Option<PathBuf>,
    pub python: Option<Maybe<String>>,
    pub workspace: bool,
    pub no_workspace: bool,
    pub no_install_project: bool,
    pub only_install_project: bool,
    pub no_install_workspace: bool,
    pub only_install_workspace: bool,
    pub no_install_local: bool,
    pub only_install_local: bool,
    pub no_install_package: Vec<PackageName>,
    pub only_install_package: Vec<PackageName>,
}

Fields

packages: Vec<String>

The packages to add, as PEP 508 requirements (e.g., ruff==0.5.0).

requirements: Vec<PathBuf>

Add the packages listed in the given files.

The following formats are supported: requirements.txt, .py files with inline metadata, pylock.toml, pyproject.toml, setup.py, and setup.cfg.

constraints: Vec<Maybe<PathBuf>>

Constrain versions using the given requirements files.

Constraints files are requirements.txt-like files that only control the version of a requirement that’s installed. The constraints will not be added to the project’s pyproject.toml file, but will be respected during dependency resolution.

This is equivalent to pip’s --constraint option.

marker: Option<MarkerTree>

Apply this marker to all added packages.

dev: bool

Add the requirements to the development dependency group.

This option is an alias for --group dev.

optional: Option<ExtraName>

Add the requirements to the package’s optional dependencies for the specified extra.

The group may then be activated when installing the project with the --extra flag.

To enable an optional extra for this requirement instead, see --extra.

group: Option<GroupName>

Add the requirements to the specified dependency group.

These requirements will not be included in the published metadata for the project.

editable: bool

Add the requirements as editable.

no_editable: bool

raw: bool

Add a dependency as provided.

By default, uv will use the tool.uv.sources section to record source information for Git, local, editable, and direct URL requirements. When --raw is provided, uv will add source requirements to project.dependencies, rather than tool.uv.sources.

Additionally, by default, uv will add bounds to your dependency, e.g., foo>=1.0.0. When --raw is provided, uv will add the dependency without bounds.

bounds: Option<AddBoundsKind>

The kind of version specifier to use when adding dependencies.

When adding a dependency to the project, if no constraint or URL is provided, a constraint is added based on the latest compatible version of the package. By default, a lower bound constraint is used, e.g., >=1.2.3.

When --frozen is provided, no resolution is performed, and dependencies are always added without constraints.

This option is in preview and may change in any future release.

rev: Option<String>

Commit to use when adding a dependency from Git.

tag: Option<String>

Tag to use when adding a dependency from Git.

branch: Option<String>

Branch to use when adding a dependency from Git.

lfs: bool

Whether to use Git LFS when adding a dependency from Git.

extra: Option<Vec<ExtraName>>

Extras to enable for the dependency.

May be provided more than once.

To add this dependency to an optional extra instead, see --optional.

no_sync: bool

Avoid syncing the virtual environment.

locked: bool

Assert that the uv.lock will remain unchanged.

Requires that the lockfile is up-to-date. If the lockfile is missing or needs to be updated, uv will exit with an error.

frozen: bool

Add dependencies without re-locking the project.

The project environment will not be synced.

active: bool

Prefer the active virtual environment over the project’s virtual environment.

If the project virtual environment is active or no virtual environment is active, this has no effect.

no_active: bool

Prefer project’s virtual environment over an active environment.

This is the default behavior.

installer: ResolverInstallerArgs

build: BuildOptionsArgs

refresh: RefreshArgs

package: Option<PackageName>

Add the dependency to a specific package in the workspace.

script: Option<PathBuf>

Add the dependency to the specified Python script, rather than to a project.

If provided, uv will add the dependency to the script’s inline metadata table, in adherence with PEP 723. If no such inline metadata table is present, a new one will be created and added to the script. When executed via uv run, uv will create a temporary environment for the script with all inline dependencies installed.

python: Option<Maybe<String>>

The Python interpreter to use for resolving and syncing.

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

workspace: bool

Add the dependency as a workspace member.

By default, uv will add path dependencies that are within the workspace directory as workspace members. When used with a path dependency, the package will be added to the workspace’s members list in the root pyproject.toml file.

no_workspace: bool

Don’t add the dependency as a workspace member.

By default, when adding a dependency that’s a local path and is within the workspace directory, uv will add it as a workspace member; pass --no-workspace to add the package as direct path dependency instead.

no_install_project: bool

Do not install the current project.

By default, the current project is installed into the environment with all of its dependencies. The --no-install-project option allows the project to be excluded, but all of its dependencies are still installed. This is particularly useful in situations like building Docker images where installing the project separately from its dependencies allows optimal layer caching.

The inverse --only-install-project can be used to install only the project itself, excluding all dependencies.

only_install_project: bool

Only install the current project.

no_install_workspace: bool

Do not install any workspace members, including the current project.

By default, all workspace members and their dependencies are installed into the environment. The --no-install-workspace option allows exclusion of all the workspace members while retaining their dependencies. This is particularly useful in situations like building Docker images where installing the workspace separately from its dependencies allows optimal layer caching.

The inverse --only-install-workspace can be used to install only workspace members, excluding all other dependencies.

only_install_workspace: bool

Only install workspace members, including the current project.

no_install_local: bool

Do not install local path dependencies

Skips the current project, workspace members, and any other local (path or editable) packages. Only remote/indexed dependencies are installed. Useful in Docker builds to cache heavy third-party dependencies first and layer local packages separately.

The inverse --only-install-local can be used to install only local packages, excluding all remote dependencies.

only_install_local: bool

Only install local path dependencies

no_install_package: Vec<PackageName>

Do not install the given package(s).

By default, all project’s dependencies are installed into the environment. The --no-install-package option allows exclusion of specific packages. Note this can result in a broken environment, and should be used with caution.

The inverse --only-install-package can be used to install only the specified packages, excluding all others.

only_install_package: Vec<PackageName>

Only install the given package(s).

Trait Implementations

impl Args for AddArgs

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 AddArgs

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.