Struct SyncArgs 

pub struct SyncArgs {

    pub extra: Option<Vec<ExtraName>>,
    pub output_format: SyncFormat,
    pub all_extras: bool,
    pub no_extra: Vec<ExtraName>,
    pub no_all_extras: bool,
    pub dev: bool,
    pub no_dev: bool,
    pub only_dev: bool,
    pub group: Vec<GroupName>,
    pub no_group: Vec<GroupName>,
    pub no_default_groups: bool,
    pub only_group: Vec<GroupName>,
    pub all_groups: bool,
    pub editable: bool,
    pub no_editable: bool,
    pub inexact: bool,
    pub exact: bool,
    pub active: bool,
    pub no_active: 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>,
    pub locked: bool,
    pub frozen: bool,
    pub dry_run: bool,
    pub installer: ResolverInstallerArgs,
    pub build: BuildOptionsArgs,
    pub refresh: RefreshArgs,
    pub all_packages: bool,
    pub package: Vec<PackageName>,
    pub script: Option<PathBuf>,
    pub python: Option<Maybe<String>>,
    pub python_platform: Option<TargetTriple>,
    pub check: bool,
    pub no_check: bool,
}

Fields

extra: Option<Vec<ExtraName>>

Include optional dependencies from the specified extra name.

May be provided more than once.

When multiple extras or groups are specified that appear in tool.uv.conflicts, uv will report an error.

Note that all optional dependencies are always included in the resolution; this option only affects the selection of packages to install.

output_format: SyncFormat

Select the output format.

all_extras: bool

Include all optional dependencies.

When two or more extras are declared as conflicting in tool.uv.conflicts, using this flag will always result in an error.

Note that all optional dependencies are always included in the resolution; this option only affects the selection of packages to install.

no_extra: Vec<ExtraName>

Exclude the specified optional dependencies, if --all-extras is supplied.

May be provided multiple times.

no_all_extras: bool

dev: bool

Include the development dependency group.

This option is an alias for --group dev.

no_dev: bool

Disable the development dependency group.

This option is an alias of --no-group dev. See --no-default-groups to disable all default groups instead.

only_dev: bool

Only include the development dependency group.

The project and its dependencies will be omitted.

This option is an alias for --only-group dev. Implies --no-default-groups.

group: Vec<GroupName>

Include dependencies from the specified dependency group.

When multiple extras or groups are specified that appear in tool.uv.conflicts, uv will report an error.

May be provided multiple times.

no_group: Vec<GroupName>

Disable the specified dependency group.

This option always takes precedence over default groups, --all-groups, and --group.

May be provided multiple times.

no_default_groups: bool

Ignore the default dependency groups.

uv includes the groups defined in tool.uv.default-groups by default. This disables that option, however, specific groups can still be included with --group.

only_group: Vec<GroupName>

Only include dependencies from the specified dependency group.

The project and its dependencies will be omitted.

May be provided multiple times. Implies --no-default-groups.

all_groups: bool

Include dependencies from all dependency groups.

--no-group can be used to exclude specific groups.

editable: bool

Install any non-editable dependencies, including the project and any workspace members, as editable.

no_editable: bool

Install any editable dependencies, including the project and any workspace members, as non-editable.

inexact: bool

Do not remove extraneous packages present in the environment.

When enabled, uv will make the minimum necessary changes to satisfy the requirements. By default, syncing will remove any extraneous packages from the environment

exact: bool

Perform an exact sync, removing extraneous packages.

active: bool

Sync dependencies to the active virtual environment.

Instead of creating or updating the virtual environment for the project or script, the active virtual environment will be preferred, if the VIRTUAL_ENV environment variable is set.

no_active: bool

Prefer project’s virtual environment over an active environment.

This is the default behavior.

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 root 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 root 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 of the 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).

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

Sync without updating the uv.lock file.

Instead of checking if the lockfile is up-to-date, uses the versions in the lockfile as the source of truth. If the lockfile is missing, uv will exit with an error. If the pyproject.toml includes changes to dependencies that have not been included in the lockfile yet, they will not be present in the environment.

dry_run: bool

Perform a dry run, without writing the lockfile or modifying the project environment.

In dry-run mode, uv will resolve the project’s dependencies and report on the resulting changes to both the lockfile and the project environment, but will not modify either.

installer: ResolverInstallerArgs

build: BuildOptionsArgs

refresh: RefreshArgs

all_packages: bool

Sync all packages in the workspace.

The workspace’s environment (.venv) is updated to include all workspace members.

Any extras or groups specified via --extra, --group, or related options will be applied to all workspace members.

package: Vec<PackageName>

Sync for specific packages in the workspace.

The workspace’s environment (.venv) is updated to reflect the subset of dependencies declared by the specified workspace member packages.

If any workspace member does not exist, uv will exit with an error.

script: Option<PathBuf>

Sync the environment for a Python script, rather than the current project.

If provided, uv will sync the dependencies based on the script’s inline metadata table, in adherence with PEP 723.

python: Option<Maybe<String>>

The Python interpreter to use for the project environment.

By default, the first interpreter that meets the project’s requires-python constraint is used.

If a Python interpreter in a virtual environment is provided, the packages will not be synced to the given environment. The interpreter will be used to create a virtual environment in the project.

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

python_platform: Option<TargetTriple>

The platform for which requirements should be installed.

Represented as a “target triple”, a string that describes the target platform in terms of its CPU, vendor, and operating system name, like x86_64-unknown-linux-gnu or aarch64-apple-darwin.

When targeting macOS (Darwin), the default minimum version is 13.0. Use MACOSX_DEPLOYMENT_TARGET to specify a different minimum version, e.g., 14.0.

When targeting iOS, the default minimum version is 13.0. Use IPHONEOS_DEPLOYMENT_TARGET to specify a different minimum version, e.g., 14.0.

When targeting Android, the default minimum Android API level is 24. Use ANDROID_API_LEVEL to specify a different minimum version, e.g., 26.

WARNING: When specified, uv will select wheels that are compatible with the target platform; as a result, the installed distributions may not be compatible with the current platform. Conversely, any distributions that are built from source may be incompatible with the target platform, as they will be built for the current platform. The --python-platform option is intended for advanced use cases.

check: bool

Check if the Python environment is synchronized with the project.

If the environment is not up to date, uv will exit with an error.

no_check: bool

Trait Implementations

impl Args for SyncArgs

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 SyncArgs

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.