feat: Use global [exclude-newer] table instead

crates/pixi/tests/integration_rust/add_tests.rs

@@ -548,7 +548,6 @@ index-url = "{index_url}"
                             index: None,
                         },
                         env_markers: MarkerTree::default(),
-                        exclude_newer: None,
                     }
                 );
             }

crates/pixi/tests/integration_rust/install_tests.rs

@@ -1554,7 +1554,10 @@ async fn test_exclude_newer_per_package_dependency_override() {
     exclude-newer = "2015-12-02T02:07:43Z"
 
     [dependencies]
-    foo = {{ version = "*", exclude-newer = "0d" }}
+    foo = "*"
+
+    [exclude-newer]
+    foo = "0d"
     "#,
         channel = channel.url(),
         platform = Platform::current()
@@ -1605,8 +1608,8 @@ async fn test_exclude_newer_per_package_constraint_override() {
     [dependencies]
     foo = "*"
 
-    [constraints]
-    bar = {{ exclude-newer = "0d" }}
+    [exclude-newer]
+    bar = "0d"
     "#,
         channel = channel.url(),
         platform = Platform::current()

crates/pixi/tests/integration_rust/pypi_tests.rs

@@ -575,7 +575,10 @@ async fn test_exclude_newer_per_package_pypi_index_override() {
         python = "==3.12.0"
 
         [pypi-dependencies]
-        foo = {{ version = "*", index = "{explicit_idx_url}", exclude-newer = "0d" }}
+        foo = {{ version = "*", index = "{explicit_idx_url}" }}
+
+        [pypi-exclude-newer]
+        foo = "0d"
 
         [pypi-options]
         index-url = "{default_idx_url}"
@@ -693,7 +696,10 @@ async fn test_exclude_newer_dependency_override_pypi_index_override() {
         index-url = "{default_idx_url}"
 
         [pypi-options.dependency-overrides]
-        foo = {{ version = ">=2.0.0", index = "{explicit_idx_url}", exclude-newer = "0d" }}
+        foo = {{ version = ">=2.0.0", index = "{explicit_idx_url}" }}
+
+        [pypi-exclude-newer]
+        foo = "0d"
         "#,
         platform = platform,
         channel_url = channel.url(),

crates/pixi_command_dispatcher/src/build/conversion.rs

@@ -116,7 +116,6 @@ pub fn from_binary_spec_v1(spec: BinaryPackageSpec) -> pixi_spec::BinarySpec {
             license,
             md5,
             sha256,
-            exclude_newer: None,
         })),
     }
 }

crates/pixi_command_dispatcher/src/build/dependencies.rs

@@ -368,7 +368,6 @@ fn filter_match_specs<T: From<BinarySpec> + Clone + Hash + Eq + PartialEq>(
                     md5,
                     sha256,
                     license,
-                    exclude_newer: None,
                 })),
             };
 

crates/pixi_core/src/environment/conda_prefix.rs

@@ -73,7 +73,7 @@ impl CondaPrefixUpdaterBuilder<'_> {
         let variant_config = self.group.workspace().variants(self.platform)?;
         let exclude_newer = self
             .group
-            .exclude_newer_config_resolved(Some(self.platform))
+            .exclude_newer_config_resolved()
             .into_diagnostic()?;
 
         Ok(CondaPrefixUpdater::new(

crates/pixi_core/src/lock_file/satisfiability/mod.rs

@@ -157,9 +157,9 @@ fn verify_exclude_newer(
     environment: &Environment<'_>,
     locked_environment: &rattler_lock::Environment<'_>,
 ) -> Result<(), ExcludeNewerMismatch> {
-    for (platform, packages) in locked_environment.conda_packages_by_platform() {
+    for (_platform, packages) in locked_environment.conda_packages_by_platform() {
         let Some(exclude_newer) = environment
-            .exclude_newer_config(Some(platform))
+            .exclude_newer_config()
             .expect("environment channels were already validated")
         else {
             continue;

crates/pixi_core/src/lock_file/update.rs

@@ -783,8 +783,7 @@ impl<'p> LockFileDerivedData<'p> {
                 {
                     let pypi_indexes = self.locked_env(environment)?.pypi_indexes().cloned();
                     let index_strategy = environment.pypi_options().index_strategy.clone();
-                    let pypi_exclude_newer = environment
-                        .pypi_exclude_newer_config_resolved(Some(environment.best_platform()));
+                    let pypi_exclude_newer = environment.pypi_exclude_newer_config_resolved();
                     let skip_wheel_filename_check =
                         environment.pypi_options().skip_wheel_filename_check;
 
@@ -2265,7 +2264,7 @@ async fn spawn_solve_conda_environment_task(
     // Get the channel configuration
     let channel_config = group.workspace().channel_config();
     let exclude_newer = group
-        .exclude_newer_config_resolved(Some(platform))
+        .exclude_newer_config_resolved()
         .map_err(SolveCondaEnvironmentError::from)
         .map_err(CommandDispatcherError::Failed)?;
 
@@ -2625,8 +2624,7 @@ async fn spawn_solve_pypi_task<'p>(
         ));
     }
 
-    let exclude_newer =
-        to_exclude_newer(&grouped_environment.pypi_exclude_newer_config_resolved(Some(platform)));
+    let exclude_newer = to_exclude_newer(&grouped_environment.pypi_exclude_newer_config_resolved());
 
     // Get the system requirements for this environment
     let system_requirements = grouped_environment.system_requirements();

crates/pixi_core/src/workspace/environment.rs

@@ -833,7 +833,7 @@ mod tests {
         .unwrap();
 
         let env = workspace.environment("combined").unwrap();
-        let config = env.exclude_newer_config(None).unwrap().unwrap();
+        let config = env.exclude_newer_config().unwrap().unwrap();
         let package = PackageName::new_unchecked("polars");
 
         assert_eq!(
@@ -898,7 +898,7 @@ mod tests {
         .unwrap();
 
         let env = workspace.environment("combined").unwrap();
-        let config = env.exclude_newer_config(None).unwrap().unwrap();
+        let config = env.exclude_newer_config().unwrap().unwrap();
         let package = PackageName::new_unchecked("polars");
 
         assert_eq!(
@@ -940,17 +940,18 @@ mod tests {
         exclude-newer = "2015-12-02T02:07:43Z"
 
         [dependencies]
-        polars = { version = "*", exclude-newer = "2017-12-02T02:07:43Z" }
+        polars = "*"
         numpy = "*"
 
-        [constraints]
-        openssl = { exclude-newer = "2018-12-02T02:07:43Z" }
+        [exclude-newer]
+        polars = "2017-12-02T02:07:43Z"
+        openssl = "2018-12-02T02:07:43Z"
         "#,
         )
         .unwrap();
 
         let env = workspace.environment("default").unwrap();
-        let config = env.exclude_newer_config(None).unwrap().unwrap();
+        let config = env.exclude_newer_config().unwrap().unwrap();
         let polars = PackageName::new_unchecked("polars");
         let numpy = PackageName::new_unchecked("numpy");
         let openssl = PackageName::new_unchecked("openssl");

crates/pixi_manifest/src/features_ext.rs

@@ -115,16 +115,14 @@ pub trait FeaturesExt<'source>: HasWorkspaceManifest<'source> + HasFeaturesIter<
     /// Returns the effective exclude-newer solver configuration.
     fn exclude_newer_config(
         &self,
-        platform: Option<Platform>,
     ) -> Result<Option<rattler_solve::ExcludeNewer>, ParseChannelError> {
-        self.exclude_newer_config_resolved(platform)
+        self.exclude_newer_config_resolved()
             .map(|exclude_newer| exclude_newer.map(Into::into))
     }
 
     /// Returns the effective exclude-newer solver configuration with absolute cutoffs.
     fn exclude_newer_config_resolved(
         &self,
-        platform: Option<Platform>,
     ) -> Result<Option<ResolvedExcludeNewer>, ParseChannelError> {
         let mut exclude_newer = self
             .exclude_newer_raw()
@@ -150,74 +148,49 @@ pub trait FeaturesExt<'source>: HasWorkspaceManifest<'source> + HasFeaturesIter<
             };
         }
 
-        for (name, spec) in self
-            .combined_dependencies(platform)
-            .iter_specs()
-            .chain(self.combined_constraints(platform).iter_specs())
+        for (name, package_exclude_newer) in &self
+            .workspace_manifest()
+            .workspace
+            .exclude_newer_package_overrides
         {
-            let Some(package_exclude_newer) = spec.exclude_newer() else {
-                continue;
-            };
-
             let config = exclude_newer.get_or_insert_with(|| {
                 ResolvedExcludeNewer::from_datetime(DateTime::<Utc>::MAX_UTC)
             });
 
             *config = match package_exclude_newer {
-                ExcludeNewer::Timestamp(dt) => config.clone().with_package_cutoff(name.clone(), dt),
+                ExcludeNewer::Timestamp(dt) => {
+                    config.clone().with_package_cutoff(name.clone(), *dt)
+                }
                 ExcludeNewer::Duration(duration) => config
                     .clone()
-                    .with_package_cutoff(name.clone(), ExcludeNewer::Duration(duration).cutoff()),
+                    .with_package_cutoff(name.clone(), ExcludeNewer::Duration(*duration).cutoff()),
             };
         }
 
         Ok(exclude_newer)
     }
 
     /// Returns the effective PyPI exclude-newer solver configuration with absolute cutoffs.
-    fn pypi_exclude_newer_config_resolved(
-        &self,
-        platform: Option<Platform>,
-    ) -> ResolvedPypiExcludeNewer {
+    fn pypi_exclude_newer_config_resolved(&self) -> ResolvedPypiExcludeNewer {
         let mut exclude_newer = self
             .exclude_newer_raw()
             .map(|config| ResolvedPypiExcludeNewer::from_datetime(config.cutoff()))
             .unwrap_or_default();
 
-        for (name, specs) in self.pypi_dependencies(platform) {
-            for spec in specs {
-                let Some(package_exclude_newer) = spec.exclude_newer() else {
-                    continue;
-                };
-
-                exclude_newer = match package_exclude_newer {
-                    ExcludeNewer::Timestamp(dt) => {
-                        exclude_newer.with_package_cutoff(name.as_normalized().clone(), dt)
-                    }
-                    ExcludeNewer::Duration(duration) => exclude_newer.with_package_cutoff(
-                        name.as_normalized().clone(),
-                        ExcludeNewer::Duration(duration).cutoff(),
-                    ),
-                };
-            }
-        }
-
-        if let Some(overrides) = self.pypi_options().dependency_overrides {
-            for (name, spec) in overrides {
-                let Some(package_exclude_newer) = spec.exclude_newer() else {
-                    continue;
-                };
-
-                exclude_newer = match package_exclude_newer {
-                    ExcludeNewer::Timestamp(dt) => {
-                        exclude_newer.with_package_cutoff(name.as_normalized().clone(), dt)
-                    }
-                    ExcludeNewer::Duration(duration) => exclude_newer.with_package_cutoff(
-                        name.as_normalized().clone(),
-                        ExcludeNewer::Duration(duration).cutoff(),
-                    ),
-                };
-            }
+        for (name, package_exclude_newer) in &self
+            .workspace_manifest()
+            .workspace
+            .pypi_exclude_newer_package_overrides
+        {
+            exclude_newer = match package_exclude_newer {
+                ExcludeNewer::Timestamp(dt) => {
+                    exclude_newer.with_package_cutoff(name.as_normalized().clone(), *dt)
+                }
+                ExcludeNewer::Duration(duration) => exclude_newer.with_package_cutoff(
+                    name.as_normalized().clone(),
+                    ExcludeNewer::Duration(*duration).cutoff(),
+                ),
+            };
         }
 
         exclude_newer

crates/pixi_manifest/src/manifests/workspace.rs

@@ -3474,38 +3474,41 @@ openssl = "<2"
     }
 
     #[test]
-    fn test_package_exclude_newer_in_dependencies_and_constraints() {
+    fn test_package_exclude_newer_tables_are_parsed() {
         let contents = r#"
 [project]
 name = "foo"
 channels = []
 platforms = []
 
-[dependencies]
-polars = { version = "*", exclude-newer = "0d" }
+[exclude-newer]
+polars = "0d"
 
-[constraints]
-openssl = { exclude-newer = "0d" }
+[pypi-exclude-newer]
+boltons = "0d"
 "#;
+        use pixi_pypi_spec::PypiPackageName;
         use rattler_conda_types::PackageName;
         use std::str::FromStr;
 
         let manifest = parse_pixi_toml(contents).manifest;
-        let feature = manifest.default_feature();
-
         let polars = PackageName::from_str("polars").unwrap();
-        let run_dependencies = feature.run_dependencies(None).unwrap();
-        let polars_spec = run_dependencies.get_single(&polars).unwrap().unwrap();
         assert_eq!(
-            polars_spec.exclude_newer().map(|value| value.to_string()),
+            manifest
+                .workspace
+                .exclude_newer_package_overrides
+                .get(&polars)
+                .map(|value| value.to_string()),
             Some("0s".to_string())
         );
 
-        let openssl = PackageName::from_str("openssl").unwrap();
-        let constraints = feature.constraints(None).unwrap();
-        let openssl_spec = constraints.get_single(&openssl).unwrap().unwrap();
+        let boltons = PypiPackageName::from_str("boltons").unwrap();
         assert_eq!(
-            openssl_spec.exclude_newer().map(|value| value.to_string()),
+            manifest
+                .workspace
+                .pypi_exclude_newer_package_overrides
+                .get(&boltons)
+                .map(|value| value.to_string()),
             Some("0s".to_string())
         );
     }
@@ -3536,8 +3539,8 @@ channels = []
 platforms = []
 exclude-newer = "2015-12-02T02:07:43Z"
 
-[dependencies]
-polars = { version = "*", exclude-newer = "0d" }
+[exclude-newer]
+polars = "0d"
 "#;
 
         let before = chrono::Utc::now();
@@ -3547,7 +3550,7 @@ polars = { version = "*", exclude-newer = "0d" }
             manifest: &manifest,
             features: vec![default_feature],
         };
-        let config = features.exclude_newer_config(None).unwrap().unwrap();
+        let config = features.exclude_newer_config().unwrap().unwrap();
         let after = chrono::Utc::now();
         let package = PackageName::from_str("polars").unwrap();
         let package_cutoff = config.cutoff_for_package(&package, None);
@@ -3590,7 +3593,7 @@ exclude-newer = "2015-12-02T02:07:43Z"
             manifest: &manifest,
             features: vec![default_feature],
         };
-        let config = features.exclude_newer_config(None).unwrap().unwrap();
+        let config = features.exclude_newer_config().unwrap().unwrap();
         let after = chrono::Utc::now();
 
         let package = PackageName::from_str("polars").unwrap();