Upload src/main.rs with huggingface_hub

src/main.rs

@@ -0,0 +1,140 @@
+use anyhow::Result;
+use reqwest::{Client, header};
+use std::fs::{File, OpenOptions};
+use std::io::{BufRead, BufReader, Write};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicU64, AtomicUsize, Ordering};
+use std::time::Duration;
+use tokio::sync::Semaphore;
+use futures::stream::{self, StreamExt};
+
+const CONCURRENT: usize = 1000;  // MAXED
+const TARGET_BYTES: u64 = 300_000_000_000;
+const OUTPUT: &str = "/workspace/crawled";
+const SEEDS: &str = "/workspace/seeds_2m.txt";
+
+static TOTAL_BYTES: AtomicU64 = AtomicU64::new(0);
+static PAGES: AtomicUsize = AtomicUsize::new(0);
+static ERRORS: AtomicUsize = AtomicUsize::new(0);
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    std::fs::create_dir_all(OUTPUT)?;
+    
+    let mut headers = header::HeaderMap::new();
+    headers.insert(header::ACCEPT, "text/html,*/*".parse()?);
+    headers.insert(header::ACCEPT_LANGUAGE, "en-US,en;q=0.9".parse()?);
+    headers.insert(header::ACCEPT_ENCODING, "gzip, deflate".parse()?);
+    headers.insert(header::CACHE_CONTROL, "no-cache".parse()?);
+    
+    let client = Client::builder()
+        .timeout(Duration::from_secs(10))
+        .connect_timeout(Duration::from_secs(5))
+        .user_agent("Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36")
+        .default_headers(headers)
+        .pool_max_idle_per_host(200)
+        .pool_idle_timeout(Duration::from_secs(30))
+        .redirect(reqwest::redirect::Policy::limited(3))
+        .danger_accept_invalid_certs(true)
+        .build()?;
+    
+    println!("🔥 AGGRESSIVE CRAWLER - 1000 concurrent, NO DELAYS");
+    println!("Target: 300GB | Seeds: 2M");
+    
+    let file = File::open(SEEDS)?;
+    let seeds: Vec<String> = BufReader::new(file).lines().filter_map(|l| l.ok()).collect();
+    println!("Loaded {} seeds - FIRING", seeds.len());
+    
+    let sem = Arc::new(Semaphore::new(CONCURRENT));
+    let client = Arc::new(client);
+    
+    // Status thread
+    let start = std::time::Instant::now();
+    tokio::spawn(async move {
+        loop {
+            tokio::time::sleep(Duration::from_secs(15)).await;
+            let bytes = TOTAL_BYTES.load(Ordering::Relaxed);
+            let pages = PAGES.load(Ordering::Relaxed);
+            let errs = ERRORS.load(Ordering::Relaxed);
+            let elapsed = start.elapsed().as_secs_f64();
+            let rate = bytes as f64 / elapsed / 1_000_000.0;
+            let pct = 100.0 * bytes as f64 / TARGET_BYTES as f64;
+            let eta_h = if rate > 0.0 { (TARGET_BYTES - bytes) as f64 / rate / 1_000_000.0 / 3600.0 } else { 999.0 };
+            
+            println!("[{:.0}s] {:.2}% | {:.2} GB | {} pg | {} err | {:.1} MB/s | ETA {:.1}h", 
+                elapsed, pct, bytes as f64/1e9, pages, errs, rate, eta_h);
+        }
+    });
+    
+    // BLAST through all seeds
+    stream::iter(seeds)
+        .for_each_concurrent(CONCURRENT, |url| {
+            let client = client.clone();
+            let sem = sem.clone();
+            
+            async move {
+                if TOTAL_BYTES.load(Ordering::Relaxed) >= TARGET_BYTES { return; }
+                
+                let _permit = sem.acquire().await.unwrap();
+                
+                match client.get(&url).send().await {
+                    Ok(resp) if resp.status().is_success() => {
+                        if let Ok(html) = resp.text().await {
+                            let text = strip_html(&html);
+                            if text.len() > 300 {
+                                let n = PAGES.fetch_add(1, Ordering::Relaxed);
+                                let path = format!("{}/p_{:08}.txt", OUTPUT, n);
+                                if let Ok(mut f) = OpenOptions::new().create(true).write(true).open(&path) {
+                                    let content = format!("URL: {}\n\n{}", url, text);
+                                    let _ = f.write_all(content.as_bytes());
+                                    TOTAL_BYTES.fetch_add(content.len() as u64, Ordering::Relaxed);
+                                }
+                            }
+                        }
+                    }
+                    _ => { ERRORS.fetch_add(1, Ordering::Relaxed); }
+                }
+            }
+        })
+        .await;
+    
+    println!("✅ DONE: {} GB", TOTAL_BYTES.load(Ordering::Relaxed) / 1_000_000_000);
+    Ok(())
+}
+
+fn strip_html(html: &str) -> String {
+    let mut out = String::with_capacity(html.len() / 4);
+    let mut in_tag = false;
+    let mut skip = 0u8;
+    let bytes = html.as_bytes();
+    let len = bytes.len();
+    let mut i = 0;
+    
+    while i < len {
+        let c = bytes[i];
+        match c {
+            b'<' => {
+                in_tag = true;
+                // Check for script/style
+                if i + 7 < len {
+                    let slice = &bytes[i..i+8];
+                    if slice.eq_ignore_ascii_case(b"<script>") || slice.eq_ignore_ascii_case(b"<script ") { skip = 1; }
+                    if slice.eq_ignore_ascii_case(b"<style>s") || slice.eq_ignore_ascii_case(b"<style s") { skip = 2; }
+                }
+                if i + 8 < len && skip == 1 && bytes[i..i+9].eq_ignore_ascii_case(b"</script>") { skip = 0; }
+                if i + 7 < len && skip == 2 && bytes[i..i+8].eq_ignore_ascii_case(b"</style>") { skip = 0; }
+            }
+            b'>' => { in_tag = false; }
+            _ if !in_tag && skip == 0 => {
+                if c.is_ascii_whitespace() {
+                    if !out.ends_with(' ') && !out.is_empty() { out.push(' '); }
+                } else {
+                    out.push(c as char);
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+    out
+}