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

uv_settings/
lib.rs
