Struct ExportArgs 

pub struct ExportArgs {

    pub format: Option<ExportFormat>,
    pub all_packages: bool,
    pub package: Vec<PackageName>,
    pub prune: Vec<PackageName>,
    pub extra: Option<Vec<ExtraName>>,
    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 no_annotate: bool,
    pub annotate: bool,
    pub no_header: bool,
    pub header: bool,
    pub editable: bool,
    pub no_editable: bool,
    pub hashes: bool,
    pub no_hashes: bool,
    pub output_file: Option<PathBuf>,
    pub no_emit_project: bool,
    pub only_emit_project: bool,
    pub no_emit_workspace: bool,
    pub only_emit_workspace: bool,
    pub no_emit_local: bool,
    pub only_emit_local: bool,
    pub no_emit_package: Vec<PackageName>,
    pub only_emit_package: Vec<PackageName>,
    pub locked: bool,
    pub frozen: bool,
    pub resolver: ResolverArgs,
    pub build: BuildOptionsArgs,
    pub refresh: RefreshArgs,
    pub script: Option<PathBuf>,
    pub python: Option<Maybe<String>>,
}

Fields

format: Option<ExportFormat>

The format to which uv.lock should be exported.

Supports requirements.txt, pylock.toml (PEP 751) and CycloneDX v1.5 JSON output formats.

uv will infer the output format from the file extension of the output file, if provided. Otherwise, defaults to requirements.txt.

all_packages: bool

Export the entire workspace.

The dependencies for all workspace members will be included in the exported requirements file.

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

package: Vec<PackageName>

Export the dependencies for specific packages in the workspace.

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

prune: Vec<PackageName>

Prune the given package from the dependency tree.

Pruned packages will be excluded from the exported requirements file, as will any dependencies that are no longer required after the pruned package is removed.

extra: Option<Vec<ExtraName>>

Include optional dependencies from the specified extra name.

May be provided more than once.

all_extras: bool

Include all optional dependencies.

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.

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.

no_annotate: bool

Exclude comment annotations indicating the source of each package.

annotate: bool

no_header: bool

Exclude the comment header at the top of the generated output file.

header: bool

editable: bool

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

no_editable: bool

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

hashes: bool

Include hashes for all dependencies.

no_hashes: bool

Omit hashes in the generated output.

output_file: Option<PathBuf>

Write the exported requirements to the given file.

no_emit_project: bool

Do not emit the current project.

By default, the current project is included in the exported requirements file with all of its dependencies. The --no-emit-project option allows the project to be excluded, but all of its dependencies to remain included.

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

only_emit_project: bool

Only emit the current project.

no_emit_workspace: bool

Do not emit any workspace members, including the root project.

By default, all workspace members and their dependencies are included in the exported requirements file, with all of their dependencies. The --no-emit-workspace option allows exclusion of all the workspace members while retaining their dependencies.

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

only_emit_workspace: bool

Only emit workspace members, including the root project.

no_emit_local: bool

Do not include local path dependencies in the exported requirements.

Omits the current project, workspace members, and any other local (path or editable) packages from the export. Only remote/indexed dependencies are written. Useful for Docker and CI flows that want to export and cache third-party dependencies first.

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

only_emit_local: bool

Only include local path dependencies in the exported requirements.

no_emit_package: Vec<PackageName>

Do not emit the given package(s).

By default, all project’s dependencies are included in the exported requirements file. The --no-emit-package option allows exclusion of specific packages.

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

only_emit_package: Vec<PackageName>

Only emit 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

Do not update the uv.lock before exporting.

If a uv.lock does not exist, uv will exit with an error.

resolver: ResolverArgs

build: BuildOptionsArgs

refresh: RefreshArgs

script: Option<PathBuf>

Export the dependencies for the specified PEP 723 Python script, rather than the current project.

If provided, uv will resolve the dependencies based on its inline metadata table, in adherence with PEP 723.

python: Option<Maybe<String>>

The Python interpreter to use during resolution.

A Python interpreter is required for building source distributions to determine package metadata when there are not wheels.

The interpreter is also used as the fallback value for the minimum Python version if requires-python is not set.

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

Trait Implementations

impl Args for ExportArgs

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 ExportArgs

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.