Address PR review: add insert_many for atomic batch inserts, add #[must_use] to get_or_insert_with

Co-authored-by: karthiknadig <[email protected]>

Author: Copilot

crates/pet-core/src/cache.rs

@@ -44,11 +44,23 @@ impl<K: Eq + Hash, V: Clone> LocatorCache<K, V> {
         self.cache.write().unwrap().insert(key, value)
     }
 
+    /// Inserts multiple key-value pairs into the cache atomically.
+    ///
+    /// This method acquires a single write lock for all insertions, which is more
+    /// efficient than calling `insert` multiple times when inserting many entries.
+    pub fn insert_many(&self, entries: impl IntoIterator<Item = (K, V)>) {
+        let mut cache = self.cache.write().unwrap();
+        for (key, value) in entries {
+            cache.insert(key, value);
+        }
+    }
+
     /// Returns a cloned value for the given key if it exists, otherwise computes
     /// and inserts the value using the provided closure.
     ///
     /// This method first checks with a read lock, then upgrades to a write lock
     /// if the value needs to be computed and inserted.
+    #[must_use]
     pub fn get_or_insert_with<F>(&self, key: K, f: F) -> Option<V>
     where
         F: FnOnce() -> Option<V>,
@@ -179,4 +191,22 @@ mod tests {
         values.sort();
         assert_eq!(values, vec![42, 100]);
     }
+
+    #[test]
+    fn test_cache_insert_many() {
+        let cache: LocatorCache<String, i32> = LocatorCache::new();
+
+        let entries = vec![
+            ("key1".to_string(), 42),
+            ("key2".to_string(), 100),
+            ("key3".to_string(), 200),
+        ];
+
+        cache.insert_many(entries);
+
+        assert_eq!(cache.len(), 3);
+        assert_eq!(cache.get(&"key1".to_string()), Some(42));
+        assert_eq!(cache.get(&"key2".to_string()), Some(100));
+        assert_eq!(cache.get(&"key3".to_string()), Some(200));
+    }
 }

crates/pet-linux-global-python/src/lib.rs

@@ -118,15 +118,19 @@ fn find_and_report_global_pythons_in(
         if let Some(resolved) = ResolvedPythonEnv::from(exe) {
             if let Some(env) = get_python_in_bin(&resolved.to_python_env(), resolved.is64_bit) {
                 resolved.add_to_cache(env.clone());
-                // env.symlinks = Some([symlinks, env.symlinks.clone().unwrap_or_default()].concat());
+
+                // Collect all entries to insert atomically
+                let mut entries = Vec::new();
                 if let Some(symlinks) = &env.symlinks {
                     for symlink in symlinks {
-                        reported_executables.insert(symlink.clone(), env.clone());
+                        entries.push((symlink.clone(), env.clone()));
                     }
                 }
                 if let Some(exe) = env.executable.clone() {
-                    reported_executables.insert(exe, env.clone());
+                    entries.push((exe, env.clone()));
                 }
+                reported_executables.insert_many(entries);
+
                 if let Some(reporter) = reporter {
                     reporter.report_environment(&env);
                 }