1use uv_configuration::{BuildOptions, IndexStrategy};
2use uv_pypi_types::SupportedEnvironments;
3use uv_torch::TorchStrategy;
4
5use crate::fork_strategy::ForkStrategy;
6use crate::{DependencyMode, ExcludeNewer, PrereleaseMode, ResolutionMode};
7
8#[derive(Debug, Default, Clone, PartialEq, Eq)]
10pub struct Options {
11 pub resolution_mode: ResolutionMode,
12 pub prerelease_mode: PrereleaseMode,
13 pub dependency_mode: DependencyMode,
14 pub fork_strategy: ForkStrategy,
15 pub exclude_newer: ExcludeNewer,
16 pub index_strategy: IndexStrategy,
17 pub required_environments: SupportedEnvironments,
18 pub flexibility: Flexibility,
19 pub build_options: BuildOptions,
20 pub torch_backend: Option<TorchStrategy>,
21}
22
23#[derive(Debug, Default, Clone)]
25pub struct OptionsBuilder {
26 resolution_mode: ResolutionMode,
27 prerelease_mode: PrereleaseMode,
28 dependency_mode: DependencyMode,
29 fork_strategy: ForkStrategy,
30 exclude_newer: ExcludeNewer,
31 index_strategy: IndexStrategy,
32 required_environments: SupportedEnvironments,
33 flexibility: Flexibility,
34 build_options: BuildOptions,
35 torch_backend: Option<TorchStrategy>,
36}
37
38impl OptionsBuilder {
39 pub fn new() -> Self {
41 Self::default()
42 }
43
44 #[must_use]
46 pub fn resolution_mode(mut self, resolution_mode: ResolutionMode) -> Self {
47 self.resolution_mode = resolution_mode;
48 self
49 }
50
51 #[must_use]
53 pub fn prerelease_mode(mut self, prerelease_mode: PrereleaseMode) -> Self {
54 self.prerelease_mode = prerelease_mode;
55 self
56 }
57
58 #[must_use]
60 pub fn dependency_mode(mut self, dependency_mode: DependencyMode) -> Self {
61 self.dependency_mode = dependency_mode;
62 self
63 }
64
65 #[must_use]
67 pub fn fork_strategy(mut self, fork_strategy: ForkStrategy) -> Self {
68 self.fork_strategy = fork_strategy;
69 self
70 }
71
72 #[must_use]
74 pub fn exclude_newer(mut self, exclude_newer: ExcludeNewer) -> Self {
75 self.exclude_newer = exclude_newer;
76 self
77 }
78
79 #[must_use]
81 pub fn index_strategy(mut self, index_strategy: IndexStrategy) -> Self {
82 self.index_strategy = index_strategy;
83 self
84 }
85
86 #[must_use]
88 pub fn required_environments(mut self, required_environments: SupportedEnvironments) -> Self {
89 self.required_environments = required_environments;
90 self
91 }
92
93 #[must_use]
95 pub fn flexibility(mut self, flexibility: Flexibility) -> Self {
96 self.flexibility = flexibility;
97 self
98 }
99
100 #[must_use]
102 pub fn build_options(mut self, build_options: BuildOptions) -> Self {
103 self.build_options = build_options;
104 self
105 }
106
107 #[must_use]
109 pub fn torch_backend(mut self, torch_backend: Option<TorchStrategy>) -> Self {
110 self.torch_backend = torch_backend;
111 self
112 }
113
114 pub fn build(self) -> Options {
116 Options {
117 resolution_mode: self.resolution_mode,
118 prerelease_mode: self.prerelease_mode,
119 dependency_mode: self.dependency_mode,
120 fork_strategy: self.fork_strategy,
121 exclude_newer: self.exclude_newer,
122 index_strategy: self.index_strategy,
123 required_environments: self.required_environments,
124 flexibility: self.flexibility,
125 build_options: self.build_options,
126 torch_backend: self.torch_backend,
127 }
128 }
129}
130
131#[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
135pub enum Flexibility {
136 #[default]
138 Configurable,
139 Fixed,
141}