uv_settings/
lib.rs

1use std::num::NonZeroUsize;
2use std::ops::Deref;
3use std::path::{Path, PathBuf};
4use std::str::FromStr;
5use std::time::Duration;
6use tracing::info_span;
7use uv_client::{DEFAULT_CONNECT_TIMEOUT, DEFAULT_READ_TIMEOUT, DEFAULT_READ_TIMEOUT_UPLOAD};
8use uv_configuration::RequiredVersion;
9use uv_dirs::{system_config_file, user_config_dir};
10use uv_distribution_types::{IndexUrlError, Origin};
11use uv_flags::EnvironmentFlags;
12use uv_fs::Simplified;
13use uv_normalize::{GroupName, PackageName};
14use uv_pep440::Version;
15use uv_python::PythonArchitecture;
16use uv_redacted::DisplaySafeUrl;
17use uv_static::{EnvVars, InvalidEnvironmentVariable, parse_boolish_environment_variable};
18use uv_torch::AmdGpuArchitecture;
19use uv_warnings::warn_user;
20
21pub use crate::combine::*;
22pub use crate::settings::*;
23
24mod combine;
25mod settings;
26
27/// The [`Options`] as loaded from a configuration file on disk.
28#[derive(Debug, Clone)]
29pub struct FilesystemOptions(Options);
30
31impl FilesystemOptions {
32    /// Convert the [`FilesystemOptions`] into [`Options`].
33    pub fn into_options(self) -> Options {
34        self.0
35    }
36
37    /// Resolve the [`FilesystemOptions`] relative to the given root directory.
38    pub fn relative_to(self, root_dir: &Path) -> Result<Self, IndexUrlError> {
39        Ok(Self(self.0.relative_to(root_dir)?))
40    }
41}
42
43impl Deref for FilesystemOptions {
44    type Target = Options;
45
46    fn deref(&self) -> &Self::Target {
47        &self.0
48    }
49}
50
51impl FilesystemOptions {
52    /// Load the user [`FilesystemOptions`].
53    pub fn user() -> Result<Option<Self>, Error> {
54        let Some(dir) = user_config_dir() else {
55            return Ok(None);
56        };
57        let root = dir.join("uv");
58        let file = root.join("uv.toml");
59
60        tracing::debug!("Searching for user configuration in: {}", file.display());
61        match read_file(&file) {
62            Ok(options) => {
63                tracing::debug!("Found user configuration in: {}", file.display());
64                validate_uv_toml(&file, &options)?;
65                Ok(Some(Self(options.with_origin(Origin::User))))
66            }
67            Err(Error::Io(err))
68                if matches!(
69                    err.kind(),
70                    std::io::ErrorKind::NotFound
71                        | std::io::ErrorKind::NotADirectory
72                        | std::io::ErrorKind::PermissionDenied
73                ) =>
74            {
75                Ok(None)
76            }
77            Err(err) => Err(err),
78        }
79    }
80
81    pub fn system() -> Result<Option<Self>, Error> {
82        if parse_boolish_environment_variable(EnvVars::UV_NO_SYSTEM_CONFIG)? == Some(true) {
83            return Ok(None);
84        }
85
86        let Some(file) = system_config_file() else {
87            return Ok(None);
88        };
89
90        tracing::debug!("Found system configuration in: {}", file.display());
91        let options = read_file(&file)?;
92        validate_uv_toml(&file, &options)?;
93        Ok(Some(Self(options.with_origin(Origin::System))))
94    }
95
96    /// Find the [`FilesystemOptions`] for the given path.
97    ///
98    /// The search starts at the given path and goes up the directory tree until a `uv.toml` file or
99    /// `pyproject.toml` file is found.
100    pub fn find(path: &Path) -> Result<Option<Self>, Error> {
101        for ancestor in path.ancestors() {
102            match Self::from_directory(ancestor) {
103                Ok(Some(options)) => {
104                    return Ok(Some(options));
105                }
106                Ok(None) => {
107                    // Continue traversing the directory tree.
108                }
109                Err(Error::PyprojectToml(path, err)) => {
110                    // If we see an invalid `pyproject.toml`, warn but continue.
111                    warn_user!(
112                        "Failed to parse `{}` during settings discovery:\n{}",
113                        path.user_display().cyan(),
114                        textwrap::indent(&err.to_string(), "  ")
115                    );
116                }
117                Err(err) => {
118                    // Otherwise, warn and stop.
119                    return Err(err);
120                }
121            }
122        }
123        Ok(None)
124    }
125
126    /// Load a [`FilesystemOptions`] from a directory, preferring a `uv.toml` file over a
127    /// `pyproject.toml` file.
128    fn from_directory(dir: &Path) -> Result<Option<Self>, Error> {
129        // Read a `uv.toml` file in the current directory.
130        let path = dir.join("uv.toml");
131        match fs_err::read_to_string(&path) {
132            Ok(content) => {
133                let options =
134                    info_span!("toml::from_str filesystem options uv.toml", path = %path.display())
135                        .in_scope(|| toml::from_str::<Options>(&content))
136                        .map_err(|err| {
137                            check_uv_toml_required_version(
138                                &path,
139                                &content,
140                                Error::UvToml(path.clone(), Box::new(err)),
141                            )
142                        })?
143                        .relative_to(&std::path::absolute(dir)?)?;
144
145                // If the directory also contains a `[tool.uv]` table in a `pyproject.toml` file,
146                // warn.
147                let pyproject = dir.join("pyproject.toml");
148                if let Ok(content) = fs_err::read_to_string(&pyproject) {
149                    let result = info_span!("toml::from_str filesystem options pyproject.toml", path = %pyproject.display())
150                        .in_scope(|| toml::from_str::<PyProjectToml>(&content)).ok();
151                    if let Some(options) =
152                        result.and_then(|pyproject| pyproject.tool.and_then(|tool| tool.uv))
153                    {
154                        warn_uv_toml_masked_fields(&options);
155                    }
156                }
157
158                tracing::debug!("Found workspace configuration at `{}`", path.display());
159                validate_uv_toml(&path, &options)?;
160                return Ok(Some(Self(options.with_origin(Origin::Project))));
161            }
162            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
163            Err(err) => return Err(err.into()),
164        }
165
166        // Read a `pyproject.toml` file in the current directory.
167        let path = dir.join("pyproject.toml");
168        match fs_err::read_to_string(&path) {
169            Ok(content) => {
170                // Parse, but skip any `pyproject.toml` that doesn't have a `[tool.uv]` section.
171                let pyproject =
172                    info_span!("toml::from_str filesystem options pyproject.toml", path = %path.display())
173                        .in_scope(|| toml::from_str::<PyProjectToml>(&content))
174                        .map_err(|err| {
175                            check_pyproject_required_version(&path, &content, err)
176                        })?;
177                let Some(tool) = pyproject.tool else {
178                    tracing::debug!(
179                        "Skipping `pyproject.toml` in `{}` (no `[tool]` section)",
180                        dir.display()
181                    );
182                    return Ok(None);
183                };
184                let Some(options) = tool.uv else {
185                    tracing::debug!(
186                        "Skipping `pyproject.toml` in `{}` (no `[tool.uv]` section)",
187                        dir.display()
188                    );
189                    return Ok(None);
190                };
191
192                let options = options.relative_to(&std::path::absolute(dir)?)?;
193
194                tracing::debug!("Found workspace configuration at `{}`", path.display());
195                return Ok(Some(Self(options)));
196            }
197            Err(err) if err.kind() == std::io::ErrorKind::NotFound => {}
198            Err(err) => return Err(err.into()),
199        }
200
201        Ok(None)
202    }
203
204    /// Load a [`FilesystemOptions`] from a `uv.toml` file.
205    pub fn from_file(path: impl AsRef<Path>) -> Result<Self, Error> {
206        let path = path.as_ref();
207        tracing::debug!("Reading user configuration from: {}", path.display());
208
209        let options = read_file(path)?;
210        validate_uv_toml(path, &options)?;
211        Ok(Self(options))
212    }
213}
214
215impl From<Options> for FilesystemOptions {
216    fn from(options: Options) -> Self {
217        Self(options)
218    }
219}
220
221/// Load [`Options`] from a `uv.toml` file.
222fn read_file(path: &Path) -> Result<Options, Error> {
223    let content = fs_err::read_to_string(path)?;
224    let options = info_span!("toml::from_str filesystem options uv.toml", path = %path.display())
225        .in_scope(|| toml::from_str::<Options>(&content))
226        .map_err(|err| {
227            check_uv_toml_required_version(
228                path,
229                &content,
230                Error::UvToml(path.to_path_buf(), Box::new(err)),
231            )
232        })?;
233    let options = if let Some(parent) = std::path::absolute(path)?.parent() {
234        options.relative_to(parent)?
235    } else {
236        options
237    };
238    Ok(options)
239}
240
241/// If `required_version` is set and incompatible with the running uv, return the corresponding
242/// [`Error::RequiredVersion`].
243fn required_version_mismatch(required_version: Option<RequiredVersion>) -> Option<Error> {
244    let required_version = required_version?;
245    let package_version = Version::from_str(uv_version::version())
246        .expect("uv crate version to be a valid PEP 440 version");
247    if required_version.contains(&package_version) {
248        None
249    } else {
250        Some(Error::RequiredVersion {
251            required_version,
252            package_version,
253        })
254    }
255}
256
257/// On a `pyproject.toml` settings parse error, check whether `tool.uv.required-version` should
258/// take precedence over that error.
259fn check_pyproject_required_version(path: &Path, content: &str, source: toml::de::Error) -> Error {
260    let fallback = || Error::PyprojectToml(path.to_path_buf(), Box::new(source));
261    let Ok(pyproject) = info_span!(
262        "toml::from_str filesystem required-version pyproject.toml",
263        path = %path.display()
264    )
265    .in_scope(|| toml::from_str::<PyProjectRequiredVersionToml>(content)) else {
266        return fallback();
267    };
268
269    let required_version = pyproject
270        .tool
271        .and_then(|tool| tool.uv)
272        .and_then(|uv| uv.required_version);
273    required_version_mismatch(required_version).unwrap_or_else(fallback)
274}
275
276/// On a `uv.toml` settings parse or schema error, check whether top-level `required-version`
277/// should take precedence over that error.
278fn check_uv_toml_required_version(path: &Path, content: &str, source: Error) -> Error {
279    let Ok(uv_toml) = info_span!(
280        "toml::from_str filesystem required-version uv.toml",
281        path = %path.display()
282    )
283    .in_scope(|| toml::from_str::<UvRequiredVersionToml>(content)) else {
284        return source;
285    };
286    required_version_mismatch(uv_toml.required_version).unwrap_or(source)
287}
288
289/// Validate that an [`Options`] schema is compatible with `uv.toml`.
290fn validate_uv_toml(path: &Path, options: &Options) -> Result<(), Error> {
291    // A `required-version` mismatch takes precedence over a schema error.
292    if let Some(err) = required_version_mismatch(options.globals.required_version.clone()) {
293        return Err(err);
294    }
295    let Options {
296        globals: _,
297        top_level: _,
298        install_mirrors: _,
299        publish: _,
300        add: _,
301        audit: _,
302        pip: _,
303        cache_keys: _,
304        override_dependencies: _,
305        exclude_dependencies: _,
306        constraint_dependencies: _,
307        build_constraint_dependencies: _,
308        environments,
309        required_environments,
310        minimum_libc_version,
311        conflicts,
312        workspace,
313        sources,
314        dev_dependencies,
315        default_groups,
316        dependency_groups,
317        managed,
318        package,
319        build_backend,
320    } = options;
321    // The `uv.toml` format is not allowed to include any of the following, which are
322    // permitted by the schema since they _can_ be included in `pyproject.toml` files
323    // (and we want to use `deny_unknown_fields`).
324    if conflicts.is_some() {
325        return Err(Error::PyprojectOnlyField(path.to_path_buf(), "conflicts"));
326    }
327    if workspace.is_some() {
328        return Err(Error::PyprojectOnlyField(path.to_path_buf(), "workspace"));
329    }
330    if sources.is_some() {
331        return Err(Error::PyprojectOnlyField(path.to_path_buf(), "sources"));
332    }
333    if dev_dependencies.is_some() {
334        return Err(Error::PyprojectOnlyField(
335            path.to_path_buf(),
336            "dev-dependencies",
337        ));
338    }
339    if default_groups.is_some() {
340        return Err(Error::PyprojectOnlyField(
341            path.to_path_buf(),
342            "default-groups",
343        ));
344    }
345    if dependency_groups.is_some() {
346        return Err(Error::PyprojectOnlyField(
347            path.to_path_buf(),
348            "dependency-groups",
349        ));
350    }
351    if managed.is_some() {
352        return Err(Error::PyprojectOnlyField(path.to_path_buf(), "managed"));
353    }
354    if package.is_some() {
355        return Err(Error::PyprojectOnlyField(path.to_path_buf(), "package"));
356    }
357    if build_backend.is_some() {
358        return Err(Error::PyprojectOnlyField(
359            path.to_path_buf(),
360            "build-backend",
361        ));
362    }
363    if environments.is_some() {
364        return Err(Error::PyprojectOnlyField(
365            path.to_path_buf(),
366            "environments",
367        ));
368    }
369    if required_environments.is_some() {
370        return Err(Error::PyprojectOnlyField(
371            path.to_path_buf(),
372            "required-environments",
373        ));
374    }
375    if minimum_libc_version.is_some() {
376        return Err(Error::PyprojectOnlyField(
377            path.to_path_buf(),
378            "minimum-libc-version",
379        ));
380    }
381    Ok(())
382}
383
384/// Validate that an [`Options`] contains no fields that `uv.toml` would mask
385///
386/// This is essentially the inverse of [`validate_uv_toml`].
387#[allow(deprecated)]
388fn warn_uv_toml_masked_fields(options: &Options) {
389    let Options {
390        globals:
391            GlobalOptions {
392                required_version,
393                system_certs,
394                native_tls,
395                offline,
396                no_cache,
397                cache_dir,
398                preview,
399                python_preference,
400                python_downloads,
401                concurrent_downloads,
402                concurrent_builds,
403                concurrent_installs,
404                allow_insecure_host,
405                http_proxy,
406                https_proxy,
407                no_proxy,
408            },
409        top_level:
410            ResolverInstallerSchema {
411                index,
412                index_url,
413                extra_index_url,
414                no_index,
415                find_links,
416                index_strategy,
417                keyring_provider,
418                resolution,
419                prerelease,
420                prerelease_package,
421                fork_strategy,
422                dependency_metadata,
423                config_settings,
424                config_settings_package,
425                no_build_isolation,
426                no_build_isolation_package,
427                extra_build_dependencies,
428                extra_build_variables,
429                exclude_newer,
430                exclude_newer_package,
431                link_mode,
432                compile_bytecode,
433                no_sources,
434                no_sources_package: _,
435                upgrade,
436                upgrade_package,
437                reinstall,
438                reinstall_package,
439                no_build,
440                no_build_package,
441                no_binary,
442                no_binary_package,
443                torch_backend,
444            },
445        install_mirrors:
446            PythonInstallMirrors {
447                python_install_mirror,
448                pypy_install_mirror,
449                python_downloads_json_url,
450            },
451        publish:
452            PublishOptions {
453                publish_url,
454                trusted_publishing,
455                check_url,
456            },
457        add: AddOptions { add_bounds },
458        audit: _,
459        pip,
460        cache_keys,
461        override_dependencies,
462        exclude_dependencies,
463        constraint_dependencies,
464        build_constraint_dependencies,
465        environments: _,
466        required_environments: _,
467        minimum_libc_version: _,
468        conflicts: _,
469        workspace: _,
470        sources: _,
471        dev_dependencies: _,
472        default_groups: _,
473        dependency_groups: _,
474        managed: _,
475        package: _,
476        build_backend: _,
477    } = options;
478
479    let mut masked_fields = vec![];
480
481    if required_version.is_some() {
482        masked_fields.push("required-version");
483    }
484    if system_certs.is_some() {
485        masked_fields.push("system-certs");
486    }
487    if native_tls.is_some() {
488        masked_fields.push("native-tls");
489    }
490    if offline.is_some() {
491        masked_fields.push("offline");
492    }
493    if no_cache.is_some() {
494        masked_fields.push("no-cache");
495    }
496    if cache_dir.is_some() {
497        masked_fields.push("cache-dir");
498    }
499    match preview {
500        Some(PreviewOption::Preview(_)) => masked_fields.push("preview"),
501        Some(PreviewOption::PreviewFeatures(_)) => masked_fields.push("preview-features"),
502        None => (),
503    }
504    if python_preference.is_some() {
505        masked_fields.push("python-preference");
506    }
507    if python_downloads.is_some() {
508        masked_fields.push("python-downloads");
509    }
510    if concurrent_downloads.is_some() {
511        masked_fields.push("concurrent-downloads");
512    }
513    if concurrent_builds.is_some() {
514        masked_fields.push("concurrent-builds");
515    }
516    if concurrent_installs.is_some() {
517        masked_fields.push("concurrent-installs");
518    }
519    if allow_insecure_host.is_some() {
520        masked_fields.push("allow-insecure-host");
521    }
522    if http_proxy.is_some() {
523        masked_fields.push("http-proxy");
524    }
525    if https_proxy.is_some() {
526        masked_fields.push("https-proxy");
527    }
528    if no_proxy.is_some() {
529        masked_fields.push("no-proxy");
530    }
531    if index.is_some() {
532        masked_fields.push("index");
533    }
534    if index_url.is_some() {
535        masked_fields.push("index-url");
536    }
537    if extra_index_url.is_some() {
538        masked_fields.push("extra-index-url");
539    }
540    if no_index.is_some() {
541        masked_fields.push("no-index");
542    }
543    if find_links.is_some() {
544        masked_fields.push("find-links");
545    }
546    if index_strategy.is_some() {
547        masked_fields.push("index-strategy");
548    }
549    if keyring_provider.is_some() {
550        masked_fields.push("keyring-provider");
551    }
552    if resolution.is_some() {
553        masked_fields.push("resolution");
554    }
555    if prerelease.is_some() {
556        masked_fields.push("prerelease");
557    }
558    if prerelease_package.is_some() {
559        masked_fields.push("prerelease-package");
560    }
561    if fork_strategy.is_some() {
562        masked_fields.push("fork-strategy");
563    }
564    if dependency_metadata.is_some() {
565        masked_fields.push("dependency-metadata");
566    }
567    if config_settings.is_some() {
568        masked_fields.push("config-settings");
569    }
570    if config_settings_package.is_some() {
571        masked_fields.push("config-settings-package");
572    }
573    if no_build_isolation.is_some() {
574        masked_fields.push("no-build-isolation");
575    }
576    if no_build_isolation_package.is_some() {
577        masked_fields.push("no-build-isolation-package");
578    }
579    if extra_build_dependencies.is_some() {
580        masked_fields.push("extra-build-dependencies");
581    }
582    if extra_build_variables.is_some() {
583        masked_fields.push("extra-build-variables");
584    }
585    if exclude_newer.is_some() {
586        masked_fields.push("exclude-newer");
587    }
588    if exclude_newer_package.is_some() {
589        masked_fields.push("exclude-newer-package");
590    }
591    if link_mode.is_some() {
592        masked_fields.push("link-mode");
593    }
594    if compile_bytecode.is_some() {
595        masked_fields.push("compile-bytecode");
596    }
597    if no_sources.is_some() {
598        masked_fields.push("no-sources");
599    }
600    if upgrade.is_some() {
601        masked_fields.push("upgrade");
602    }
603    if upgrade_package.is_some() {
604        masked_fields.push("upgrade-package");
605    }
606    if reinstall.is_some() {
607        masked_fields.push("reinstall");
608    }
609    if reinstall_package.is_some() {
610        masked_fields.push("reinstall-package");
611    }
612    if no_build.is_some() {
613        masked_fields.push("no-build");
614    }
615    if no_build_package.is_some() {
616        masked_fields.push("no-build-package");
617    }
618    if no_binary.is_some() {
619        masked_fields.push("no-binary");
620    }
621    if no_binary_package.is_some() {
622        masked_fields.push("no-binary-package");
623    }
624    if torch_backend.is_some() {
625        masked_fields.push("torch-backend");
626    }
627    if python_install_mirror.is_some() {
628        masked_fields.push("python-install-mirror");
629    }
630    if pypy_install_mirror.is_some() {
631        masked_fields.push("pypy-install-mirror");
632    }
633    if python_downloads_json_url.is_some() {
634        masked_fields.push("python-downloads-json-url");
635    }
636    if publish_url.is_some() {
637        masked_fields.push("publish-url");
638    }
639    if trusted_publishing.is_some() {
640        masked_fields.push("trusted-publishing");
641    }
642    if check_url.is_some() {
643        masked_fields.push("check-url");
644    }
645    if add_bounds.is_some() {
646        masked_fields.push("add-bounds");
647    }
648    if pip.is_some() {
649        masked_fields.push("pip");
650    }
651    if cache_keys.is_some() {
652        masked_fields.push("cache_keys");
653    }
654    if override_dependencies.is_some() {
655        masked_fields.push("override-dependencies");
656    }
657    if exclude_dependencies.is_some() {
658        masked_fields.push("exclude-dependencies");
659    }
660    if constraint_dependencies.is_some() {
661        masked_fields.push("constraint-dependencies");
662    }
663    if build_constraint_dependencies.is_some() {
664        masked_fields.push("build-constraint-dependencies");
665    }
666    if !masked_fields.is_empty() {
667        let field_listing = masked_fields.join("\n- ");
668        warn_user!(
669            "Found both a `uv.toml` file and a `[tool.uv]` section in an adjacent `pyproject.toml`. The following fields from `[tool.uv]` will be ignored in favor of the `uv.toml` file:\n- {}",
670            field_listing,
671        );
672    }
673}
674
675#[derive(thiserror::Error, Debug)]
676pub enum Error {
677    #[error(transparent)]
678    Io(#[from] std::io::Error),
679
680    #[error(transparent)]
681    Index(#[from] uv_distribution_types::IndexUrlError),
682
683    #[error("Failed to parse: {}", _0.user_display())]
684    PyprojectToml(PathBuf, #[source] Box<toml::de::Error>),
685
686    #[error("Failed to parse: {}", _0.user_display())]
687    UvToml(PathBuf, #[source] Box<toml::de::Error>),
688
689    #[error("Failed to parse `{}`. The `{}` field is not allowed in a `uv.toml` file. `{}` is only applicable in the context of a project, and should be placed in a `pyproject.toml` file instead.", _0.user_display(), _1, _1
690    )]
691    PyprojectOnlyField(PathBuf, &'static str),
692
693    #[error(
694        "Required uv version `{required_version}` does not match the running version `{package_version}`"
695    )]
696    RequiredVersion {
697        required_version: RequiredVersion,
698        package_version: Version,
699    },
700
701    #[error(transparent)]
702    InvalidEnvironmentVariable(#[from] InvalidEnvironmentVariable),
703}
704
705#[derive(Copy, Clone, Debug)]
706pub struct Concurrency {
707    pub downloads: Option<NonZeroUsize>,
708    pub builds: Option<NonZeroUsize>,
709    pub installs: Option<NonZeroUsize>,
710    pub cache_reads: Option<NonZeroUsize>,
711}
712
713/// A boolean flag parsed from an environment variable.
714///
715/// Stores both the value and the environment variable name for use in error messages.
716#[derive(Debug, Clone, Copy)]
717pub struct EnvFlag {
718    pub value: Option<bool>,
719    pub env_var: &'static str,
720}
721
722impl EnvFlag {
723    /// Create a new [`EnvFlag`] by parsing the given environment variable.
724    fn new(env_var: &'static str) -> Result<Self, Error> {
725        Ok(Self {
726            value: parse_boolish_environment_variable(env_var)?,
727            env_var,
728        })
729    }
730}
731
732/// Options loaded from environment variables.
733///
734/// This is currently a subset of all respected environment variables, most are parsed via Clap at
735/// the CLI level, however there are limited semantics in that context.
736#[derive(Debug, Clone)]
737pub struct EnvironmentOptions {
738    pub ruff_path: Option<PathBuf>,
739    pub ty_path: Option<PathBuf>,
740    pub skip_wheel_filename_check: Option<bool>,
741    pub require_metadata_range_requests: Option<bool>,
742    pub hide_build_output: Option<bool>,
743    pub python_arch: Option<PythonArchitecture>,
744    pub python_install_bin: Option<bool>,
745    pub python_install_registry: Option<bool>,
746    pub python_no_registry: EnvFlag,
747    pub install_mirrors: PythonInstallMirrors,
748    pub log_context: Option<bool>,
749    pub lfs: Option<bool>,
750    pub cuda_driver_version: Option<Version>,
751    pub amd_gpu_architecture: Option<AmdGpuArchitecture>,
752    pub http_connect_timeout: Duration,
753    pub http_read_timeout: Duration,
754    /// There's no upload timeout in reqwest, instead we have to use a read timeout as upload
755    /// timeout.
756    pub http_read_timeout_upload: Duration,
757    pub http_retries: u32,
758    pub concurrency: Concurrency,
759    #[cfg(feature = "tracing-durations-export")]
760    pub tracing_durations_file: Option<PathBuf>,
761    pub frozen: EnvFlag,
762    pub locked: EnvFlag,
763    pub offline: EnvFlag,
764    pub no_sync: EnvFlag,
765    pub managed_python: EnvFlag,
766    pub no_managed_python: EnvFlag,
767    pub native_tls: EnvFlag,
768    pub system_certs: EnvFlag,
769    pub preview: EnvFlag,
770    pub isolated: EnvFlag,
771    pub no_progress: EnvFlag,
772    pub no_installer_metadata: EnvFlag,
773    pub dev: EnvFlag,
774    pub no_dev: EnvFlag,
775    pub show_resolution: EnvFlag,
776    pub no_editable: EnvFlag,
777    pub no_install_project: EnvFlag,
778    pub no_install_workspace: EnvFlag,
779    pub no_install_local: EnvFlag,
780    pub only_install_project: EnvFlag,
781    pub only_install_workspace: EnvFlag,
782    pub only_install_local: EnvFlag,
783    pub no_env_file: EnvFlag,
784    pub no_group: Option<Vec<GroupName>>,
785    pub no_binary_package: Option<Vec<PackageName>>,
786    pub no_build_package: Option<Vec<PackageName>>,
787    pub no_sources_package: Option<Vec<PackageName>>,
788    pub venv_seed: EnvFlag,
789    pub venv_clear: EnvFlag,
790    pub venv_relocatable: EnvFlag,
791    pub init_bare: EnvFlag,
792    pub malware_check: EnvFlag,
793    pub malware_check_url: Option<DisplaySafeUrl>,
794    #[cfg(unix)]
795    pub run_rlimit_nofile: Option<u32>,
796}
797
798impl EnvironmentOptions {
799    /// Create a new [`EnvironmentOptions`] from environment variables.
800    pub fn new() -> Result<Self, Error> {
801        // Timeout options, matching https://doc.rust-lang.org/nightly/cargo/reference/config.html#httptimeout
802        // `UV_REQUEST_TIMEOUT` is provided for backwards compatibility with v0.1.6
803        let http_read_timeout = parse_integer_environment_variable(
804            EnvVars::UV_HTTP_TIMEOUT,
805            Some("value should be an integer number of seconds"),
806        )?
807        .or(parse_integer_environment_variable(
808            EnvVars::UV_REQUEST_TIMEOUT,
809            Some("value should be an integer number of seconds"),
810        )?)
811        .or(parse_integer_environment_variable(
812            EnvVars::HTTP_TIMEOUT,
813            Some("value should be an integer number of seconds"),
814        )?)
815        .map(Duration::from_secs);
816
817        // Ignore the deprecated `UV_NATIVE_TLS` variable when its replacement is set.
818        let system_certs = EnvFlag::new(EnvVars::UV_SYSTEM_CERTS)?;
819        let native_tls = if system_certs.value.is_some() {
820            EnvFlag {
821                value: None,
822                env_var: EnvVars::UV_NATIVE_TLS,
823            }
824        } else {
825            EnvFlag::new(EnvVars::UV_NATIVE_TLS)?
826        };
827
828        Ok(Self {
829            ruff_path: parse_path_environment_variable(EnvVars::RUFF),
830            ty_path: parse_path_environment_variable(EnvVars::TY),
831            skip_wheel_filename_check: parse_boolish_environment_variable(
832                EnvVars::UV_SKIP_WHEEL_FILENAME_CHECK,
833            )?,
834            require_metadata_range_requests: parse_boolish_environment_variable(
835                EnvVars::UV_REQUIRE_METADATA_RANGE_REQUESTS,
836            )?,
837            hide_build_output: parse_boolish_environment_variable(EnvVars::UV_HIDE_BUILD_OUTPUT)?,
838            python_arch: parse_typed_environment_variable(EnvVars::UV_PYTHON_ARCH, None)?,
839            python_install_bin: parse_boolish_environment_variable(EnvVars::UV_PYTHON_INSTALL_BIN)?,
840            python_install_registry: parse_boolish_environment_variable(
841                EnvVars::UV_PYTHON_INSTALL_REGISTRY,
842            )?,
843            python_no_registry: EnvFlag::new(EnvVars::UV_PYTHON_NO_REGISTRY)?,
844            concurrency: Concurrency {
845                downloads: parse_integer_environment_variable(
846                    EnvVars::UV_CONCURRENT_DOWNLOADS,
847                    None,
848                )?,
849                builds: parse_integer_environment_variable(EnvVars::UV_CONCURRENT_BUILDS, None)?,
850                installs: parse_integer_environment_variable(
851                    EnvVars::UV_CONCURRENT_INSTALLS,
852                    None,
853                )?,
854                cache_reads: parse_integer_environment_variable(
855                    EnvVars::UV_CONCURRENT_CACHE_READS,
856                    None,
857                )?,
858            },
859            install_mirrors: PythonInstallMirrors {
860                python_install_mirror: parse_string_environment_variable(
861                    EnvVars::UV_PYTHON_INSTALL_MIRROR,
862                )?,
863                pypy_install_mirror: parse_string_environment_variable(
864                    EnvVars::UV_PYPY_INSTALL_MIRROR,
865                )?,
866                python_downloads_json_url: parse_string_environment_variable(
867                    EnvVars::UV_PYTHON_DOWNLOADS_JSON_URL,
868                )?,
869            },
870            log_context: parse_boolish_environment_variable(EnvVars::UV_LOG_CONTEXT)?,
871            lfs: parse_boolish_environment_variable(EnvVars::UV_GIT_LFS)?,
872            cuda_driver_version: parse_typed_environment_variable(
873                EnvVars::UV_CUDA_DRIVER_VERSION,
874                None,
875            )?,
876            amd_gpu_architecture: parse_typed_environment_variable(
877                EnvVars::UV_AMD_GPU_ARCHITECTURE,
878                None,
879            )?,
880            http_read_timeout_upload: parse_integer_environment_variable(
881                EnvVars::UV_UPLOAD_HTTP_TIMEOUT,
882                Some("value should be an integer number of seconds"),
883            )?
884            .map(Duration::from_secs)
885            .or(http_read_timeout)
886            .unwrap_or(DEFAULT_READ_TIMEOUT_UPLOAD),
887            http_read_timeout: http_read_timeout.unwrap_or(DEFAULT_READ_TIMEOUT),
888            http_connect_timeout: parse_integer_environment_variable(
889                EnvVars::UV_HTTP_CONNECT_TIMEOUT,
890                Some("value should be an integer number of seconds"),
891            )?
892            .map(Duration::from_secs)
893            .unwrap_or(DEFAULT_CONNECT_TIMEOUT),
894            http_retries: parse_integer_environment_variable(EnvVars::UV_HTTP_RETRIES, None)?
895                .unwrap_or(uv_client::DEFAULT_RETRIES),
896            #[cfg(feature = "tracing-durations-export")]
897            tracing_durations_file: parse_path_environment_variable(
898                EnvVars::TRACING_DURATIONS_FILE,
899            ),
900            frozen: EnvFlag::new(EnvVars::UV_FROZEN)?,
901            locked: EnvFlag::new(EnvVars::UV_LOCKED)?,
902            offline: EnvFlag::new(EnvVars::UV_OFFLINE)?,
903            no_sync: EnvFlag::new(EnvVars::UV_NO_SYNC)?,
904            managed_python: EnvFlag::new(EnvVars::UV_MANAGED_PYTHON)?,
905            no_managed_python: EnvFlag::new(EnvVars::UV_NO_MANAGED_PYTHON)?,
906            native_tls,
907            system_certs,
908            preview: EnvFlag::new(EnvVars::UV_PREVIEW)?,
909            isolated: EnvFlag::new(EnvVars::UV_ISOLATED)?,
910            no_progress: EnvFlag::new(EnvVars::UV_NO_PROGRESS)?,
911            no_installer_metadata: EnvFlag::new(EnvVars::UV_NO_INSTALLER_METADATA)?,
912            dev: EnvFlag::new(EnvVars::UV_DEV)?,
913            no_dev: EnvFlag::new(EnvVars::UV_NO_DEV)?,
914            show_resolution: EnvFlag::new(EnvVars::UV_SHOW_RESOLUTION)?,
915            no_editable: EnvFlag::new(EnvVars::UV_NO_EDITABLE)?,
916            no_install_project: EnvFlag::new(EnvVars::UV_NO_INSTALL_PROJECT)?,
917            no_install_workspace: EnvFlag::new(EnvVars::UV_NO_INSTALL_WORKSPACE)?,
918            no_install_local: EnvFlag::new(EnvVars::UV_NO_INSTALL_LOCAL)?,
919            only_install_project: EnvFlag::new(EnvVars::UV_ONLY_INSTALL_PROJECT)?,
920            only_install_workspace: EnvFlag::new(EnvVars::UV_ONLY_INSTALL_WORKSPACE)?,
921            only_install_local: EnvFlag::new(EnvVars::UV_ONLY_INSTALL_LOCAL)?,
922            no_env_file: EnvFlag::new(EnvVars::UV_NO_ENV_FILE)?,
923            no_group: parse_name_list_environment_variable(EnvVars::UV_NO_GROUP)?,
924            no_binary_package: parse_name_list_environment_variable(EnvVars::UV_NO_BINARY_PACKAGE)?,
925            no_build_package: parse_name_list_environment_variable(EnvVars::UV_NO_BUILD_PACKAGE)?,
926            no_sources_package: parse_name_list_environment_variable(
927                EnvVars::UV_NO_SOURCES_PACKAGE,
928            )?,
929            venv_seed: EnvFlag::new(EnvVars::UV_VENV_SEED)?,
930            venv_clear: EnvFlag::new(EnvVars::UV_VENV_CLEAR)?,
931            venv_relocatable: EnvFlag::new(EnvVars::UV_VENV_RELOCATABLE)?,
932            init_bare: EnvFlag::new(EnvVars::UV_INIT_BARE)?,
933            malware_check: EnvFlag::new(EnvVars::UV_MALWARE_CHECK)?,
934            malware_check_url: parse_string_environment_variable(EnvVars::UV_MALWARE_CHECK_URL)?
935                .map(|value| {
936                    value.parse::<DisplaySafeUrl>().map_err(|err| {
937                        Error::InvalidEnvironmentVariable(InvalidEnvironmentVariable {
938                            name: EnvVars::UV_MALWARE_CHECK_URL.to_string(),
939                            value,
940                            err: err.to_string(),
941                        })
942                    })
943                })
944                .transpose()?,
945            #[cfg(unix)]
946            run_rlimit_nofile: parse_integer_environment_variable(
947                EnvVars::UV_RUN_RLIMIT_NOFILE,
948                None,
949            )?,
950        })
951    }
952}
953
954/// Parse a string environment variable.
955fn parse_string_environment_variable(name: &'static str) -> Result<Option<String>, Error> {
956    match std::env::var(name) {
957        Ok(v) => {
958            if v.is_empty() {
959                Ok(None)
960            } else {
961                Ok(Some(v))
962            }
963        }
964        Err(e) => match e {
965            std::env::VarError::NotPresent => Ok(None),
966            std::env::VarError::NotUnicode(err) => Err(Error::InvalidEnvironmentVariable(
967                InvalidEnvironmentVariable {
968                    name: name.to_string(),
969                    value: err.to_string_lossy().to_string(),
970                    err: "expected a valid UTF-8 string".to_string(),
971                },
972            )),
973        },
974    }
975}
976
977/// Parse an environment variable containing a whitespace-delimited list of names.
978fn parse_name_list_environment_variable<T>(name: &'static str) -> Result<Option<Vec<T>>, Error>
979where
980    T: FromStr,
981    <T as FromStr>::Err: std::fmt::Display,
982{
983    let Some(value) = parse_string_environment_variable(name)? else {
984        return Ok(None);
985    };
986
987    let names = value
988        .split_whitespace()
989        .map(|entry| {
990            entry.parse::<T>().map_err(|err| {
991                Error::InvalidEnvironmentVariable(InvalidEnvironmentVariable {
992                    name: name.to_string(),
993                    value: value.clone(),
994                    err: err.to_string(),
995                })
996            })
997        })
998        .collect::<Result<Vec<_>, _>>()?;
999
1000    if names.is_empty() {
1001        Ok(None)
1002    } else {
1003        Ok(Some(names))
1004    }
1005}
1006
1007fn parse_typed_environment_variable<T>(
1008    name: &'static str,
1009    help: Option<&str>,
1010) -> Result<Option<T>, Error>
1011where
1012    T: std::str::FromStr,
1013    <T as std::str::FromStr>::Err: std::fmt::Display,
1014{
1015    let value = match std::env::var(name) {
1016        Ok(v) => v,
1017        Err(e) => {
1018            return match e {
1019                std::env::VarError::NotPresent => Ok(None),
1020                std::env::VarError::NotUnicode(err) => Err(Error::InvalidEnvironmentVariable(
1021                    InvalidEnvironmentVariable {
1022                        name: name.to_string(),
1023                        value: err.to_string_lossy().to_string(),
1024                        err: "expected a valid UTF-8 string".to_string(),
1025                    },
1026                )),
1027            };
1028        }
1029    };
1030    if value.is_empty() {
1031        return Ok(None);
1032    }
1033
1034    match value.parse::<T>() {
1035        Ok(v) => Ok(Some(v)),
1036        Err(err) => Err(Error::InvalidEnvironmentVariable(
1037            InvalidEnvironmentVariable {
1038                name: name.to_string(),
1039                value,
1040                err: if let Some(help) = help {
1041                    format!("{err}; {help}")
1042                } else {
1043                    err.to_string()
1044                },
1045            },
1046        )),
1047    }
1048}
1049
1050fn parse_integer_environment_variable<T>(
1051    name: &'static str,
1052    help: Option<&str>,
1053) -> Result<Option<T>, Error>
1054where
1055    T: std::str::FromStr + Copy,
1056    <T as std::str::FromStr>::Err: std::fmt::Display,
1057{
1058    let value = match std::env::var(name) {
1059        Ok(v) => v,
1060        Err(e) => {
1061            return match e {
1062                std::env::VarError::NotPresent => Ok(None),
1063                std::env::VarError::NotUnicode(err) => Err(Error::InvalidEnvironmentVariable(
1064                    InvalidEnvironmentVariable {
1065                        name: name.to_string(),
1066                        value: err.to_string_lossy().to_string(),
1067                        err: "expected a valid UTF-8 string".to_string(),
1068                    },
1069                )),
1070            };
1071        }
1072    };
1073    if value.is_empty() {
1074        return Ok(None);
1075    }
1076
1077    match value.parse::<T>() {
1078        Ok(v) => Ok(Some(v)),
1079        Err(err) => Err(Error::InvalidEnvironmentVariable(
1080            InvalidEnvironmentVariable {
1081                name: name.to_string(),
1082                value,
1083                err: if let Some(help) = help {
1084                    format!("{err}; {help}")
1085                } else {
1086                    err.to_string()
1087                },
1088            },
1089        )),
1090    }
1091}
1092
1093/// Parse a path environment variable.
1094fn parse_path_environment_variable(name: &'static str) -> Option<PathBuf> {
1095    let value = std::env::var_os(name)?;
1096
1097    if value.is_empty() {
1098        return None;
1099    }
1100
1101    Some(PathBuf::from(value))
1102}
1103
1104/// Populate the [`EnvironmentFlags`] from the given [`EnvironmentOptions`].
1105impl From<&EnvironmentOptions> for EnvironmentFlags {
1106    fn from(options: &EnvironmentOptions) -> Self {
1107        let mut flags = Self::empty();
1108        if options.skip_wheel_filename_check == Some(true) {
1109            flags.insert(Self::SKIP_WHEEL_FILENAME_CHECK);
1110        }
1111        if options.hide_build_output == Some(true) {
1112            flags.insert(Self::HIDE_BUILD_OUTPUT);
1113        }
1114        flags
1115    }
1116}
uv_settings/lib.rs

uv_settings/
lib.rs
