Fix API breaking changes.

Author: gorzell

crates/bpe/src/byte_pair_encoding.rs

@@ -171,9 +171,9 @@ pub fn find_hash_factor_for_dictionary(tokens: impl IntoIterator<Item = Vec<u8>>
     use rand::Rng;
 
     let all_tokens = tokens.into_iter().collect_vec();
-    let mut rnd = rand::thread_rng();
+    let mut rnd = rand::rng();
     loop {
-        let factor: u64 = rnd.gen();
+        let factor: u64 = rnd.random();
         let mut seen = HashSet::new();
         if all_tokens
             .iter()
@@ -568,7 +568,7 @@ pub fn create_test_string_with_predicate(
     min_bytes: usize,
     predicate: impl Fn(&str) -> bool,
 ) -> String {
-    use rand::{thread_rng, Rng};
+    use rand::{rng, Rng};
     // the string we accumulated thus far
     let mut result = String::new();
     // the tokens we added so we can backtrack
@@ -577,7 +577,7 @@ pub fn create_test_string_with_predicate(
         // try a few times to find a suitable token
         'next: for _ in 0..8 {
             // pick a random token and provisionally add it
-            let i = thread_rng().gen_range(0..bpe.num_tokens()) as u32;
+            let i = rng().random_range(0..bpe.num_tokens()) as u32;
             // We only use tokens that are valid UTF-8. This is true for ~99% of tokens in OpenAI's
             // token set. The chance of constructing a valid UTF-8 character across a token boundary
             // by picking random tokens is so small that it is unlikely to happen anyway.
@@ -603,8 +603,8 @@ pub fn create_test_string_with_predicate(
 
 #[cfg(feature = "rand")]
 pub fn select_test_string(text: &str, min_bytes: usize) -> &str {
-    use rand::{thread_rng, Rng};
-    let mut start = thread_rng().gen_range(0..text.len() - min_bytes);
+    use rand::{rng, Rng};
+    let mut start = rng().random_range(0..text.len() - min_bytes);
     while !text.is_char_boundary(start) {
         start -= 1;
     }
@@ -618,10 +618,10 @@ pub fn select_test_string(text: &str, min_bytes: usize) -> &str {
 /// Generate test bytes by concatenating random tokens.
 #[cfg(feature = "rand")]
 pub fn create_test_bytes(bpe: &BytePairEncoding, min_bytes: usize) -> Vec<u8> {
-    use rand::{thread_rng, Rng};
+    use rand::{rng, Rng};
     let mut result = Vec::new();
     while result.len() < min_bytes {
-        let i = thread_rng().gen_range(0..bpe.num_tokens());
+        let i = rng().random_range(0..bpe.num_tokens());
         result.extend(bpe.token_bytes(i as u32));
     }
     result

crates/bpe/tests/src/lib.rs

@@ -1,7 +1,7 @@
 #[cfg(test)]
 mod tests {
     use itertools::Itertools;
-    use rand::{thread_rng, Rng};
+    use rand::{rng, Rng};
     use tiktoken_rs::cl100k_base_singleton;
 
     use bpe::appendable_encoder::AppendableEncoder;
@@ -122,8 +122,8 @@ mod tests {
         let input = create_test_bytes(bpe, 10000);
         let intervals = IntervalEncoding::new(bpe, &input);
         for _ in 0..1000 {
-            let start = thread_rng().gen_range(0..input.len());
-            let end = thread_rng().gen_range(0..input.len());
+            let start = rng().random_range(0..input.len());
+            let end = rng().random_range(0..input.len());
             let range = start.min(end)..start.max(end);
             assert_eq!(
                 intervals.count(range.clone()),

crates/geo_filters/Cargo.toml

@@ -36,7 +36,7 @@ regex = { version = "1", optional = true }
 criterion = "0.5"
 geo_filters = { path = ".", features = ["evaluation"] }
 rand = "0.9"
-rand_chacha = "0.3"
+rand_chacha = "0.9"
 rayon = "1.7"
 
 [[bench]]

crates/geo_filters/src/config.rs

@@ -312,7 +312,7 @@ pub(crate) mod tests {
 
     /// Runs estimation trials and returns the average precision and variance.
     pub(crate) fn test_estimate<M: Method, C: Count<M>>(f: impl Fn() -> C) -> (f32, f32) {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         let cnt = 10000usize;
         let mut avg_precision = 0.0;
         let mut avg_var = 0.0;

crates/geo_filters/src/config/lookup.rs

@@ -67,7 +67,7 @@ mod tests {
         let phi = phi_f64(B);
         let buckets = HashToBucketLookup::new(B);
         let mut var = 0.0;
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         for _ in 0..n {
             let hash = rnd.next_u64();
             let estimate = buckets.lookup(hash) as f64;

crates/geo_filters/src/diff_count.rs

@@ -446,7 +446,7 @@ mod tests {
 
     #[test]
     fn test_estimate_diff_size_fast() {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         let mut a_p = GeoDiffCount7_50::default();
         let mut a_hp = GeoDiffCount7::default();
         let mut b_p = GeoDiffCount7_50::default();
@@ -500,7 +500,7 @@ mod tests {
 
     #[test]
     fn test_xor_plus_mask() {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         let mask_size = 12;
         let mask = 0b100001100000;
         let mut a = GeoDiffCount7::default();
@@ -527,7 +527,7 @@ mod tests {
 
     #[test]
     fn test_bit_chunks() {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         for _ in 0..100 {
             let mut expected = GeoDiffCount7::default();
             for _ in 0..1000 {

crates/geo_filters/src/distinct_count.rs

@@ -307,7 +307,7 @@ mod tests {
 
     #[test]
     fn test_estimate_union_size_fast() {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         let mut a = GeoDistinctCount7::default();
         let mut b = GeoDistinctCount7::default();
         for _ in 0..10000 {
@@ -374,7 +374,7 @@ mod tests {
 
     #[test]
     fn test_bit_chunks() {
-        let mut rnd = rand::rngs::StdRng::from_entropy();
+        let mut rnd = rand::rngs::StdRng::from_os_rng();
         for _ in 0..100 {
             let mut expected = GeoDistinctCount7::default();
             for _ in 0..1000 {

crates/geo_filters/src/evaluation/simulation.rs

@@ -181,7 +181,7 @@ pub fn simulate<F: Fn() -> Box<dyn SimulationCount> + Send + Sync>(
         .map(|_| {
             let mut t = f();
             let mut last_set_size = 0;
-            let mut rnd = rand::rngs::StdRng::from_entropy();
+            let mut rnd = rand::rngs::StdRng::from_os_rng();
             set_sizes
                 .iter()
                 .map(move |set_size| {

crates/string-offsets/Cargo.toml

@@ -11,4 +11,4 @@ categories = ["algorithms", "data-structures", "text-processing", "development-t
 
 [dev-dependencies]
 rand = "0.9"
-rand_chacha = "0.3"
+rand_chacha = "0.9"

crates/string-offsets/src/bitrank.rs

@@ -214,12 +214,12 @@ impl BitRank {
 
 #[cfg(test)]
 mod tests {
-    use rand::distributions::Uniform;
+    use super::*;
+    use rand::distr::Uniform;
     use rand::prelude::*;
+    use rand_chacha::rand_core::SeedableRng;
     use rand_chacha::ChaCha8Rng;
 
-    use super::*;
-
     /// Creates a `BitRank` containing the integers in `iter` (which should be strictly
     /// increasing).
     pub fn bitrank<I: IntoIterator<Item = usize>>(iter: I) -> BitRank {
@@ -304,7 +304,7 @@ mod tests {
     #[test]
     fn test_rank_large_random() {
         let mut rng = ChaCha8Rng::seed_from_u64(2);
-        let uniform = Uniform::<usize>::from(0..1_000_000);
+        let uniform = Uniform::new(0, 1_000_000).unwrap();
         let mut random_bits = Vec::with_capacity(100_000);
         for _ in 0..100_000 {
             random_bits.push(uniform.sample(&mut rng));