Upload source/crawler_upload.go with huggingface_hub

source/crawler_upload.go

@@ -0,0 +1,738 @@
+package main
+
+import (
+	"bufio"
+	"compress/gzip"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io"
+	"math/rand"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"golang.org/x/net/html"
+)
+
+const (
+	NumWorkers       = 150
+	FetchTimeout     = 10 * time.Second
+	MinTextLen       = 200
+	MaxTextLen       = 200000
+	MaxURLsPerDomain = 1000
+	ChunkTargetBytes = 1_200_000_000
+	MaxQueueSize     = 5_000_000
+	StatusInterval   = 30 * time.Second
+	HFToken          = "YOUR_HF_TOKEN_HERE"
+	TargetRepo       = "OpenTransformer/web-crawl-2026"
+	OutputDir        = "/workspace/scraped_data_go"
+	SeedCacheDir     = "/workspace/seed_cache"
+)
+
+var blockedExtensions = map[string]bool{
+	".pdf": true, ".jpg": true, ".jpeg": true, ".png": true, ".gif": true,
+	".svg": true, ".mp3": true, ".mp4": true, ".avi": true, ".mov": true,
+	".zip": true, ".tar": true, ".gz": true, ".exe": true, ".dmg": true,
+	".css": true, ".js": true, ".woff": true, ".woff2": true, ".ttf": true,
+	".ico": true, ".webp": true, ".bmp": true, ".doc": true, ".docx": true,
+	".xls": true, ".xlsx": true, ".ppt": true, ".pptx": true, ".iso": true,
+}
+
+var blockedPattern = regexp.MustCompile(
+	`(?i)(login|signup|signin|register|cart|checkout|payment|admin|wp-admin|` +
+		`facebook\.com|twitter\.com|instagram\.com|tiktok\.com|linkedin\.com|` +
+		`youtube\.com/watch|amazon\.|ebay\.|\.pdf$|/tag/|/category/|` +
+		`/page/\d+|/feed/|/rss|/atom|#comment|/reply|/share|mailto:|tel:)`)
+
+var tagStripper = regexp.MustCompile(`<script[^>]*>[\s\S]*?</script>|<style[^>]*>[\s\S]*?</style>|<[^>]+>`)
+var whitespaceCollapse = regexp.MustCompile(`\s+`)
+
+var userAgents = []string{
+	"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36",
+	"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.2 Safari/605.1.15",
+	"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:123.0) Gecko/20100101 Firefox/123.0",
+	"Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:122.0) Gecko/20100101 Firefox/122.0",
+	"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+}
+
+type Document struct {
+	Text      string `json:"text"`
+	URL       string `json:"url"`
+	Domain    string `json:"domain"`
+	Timestamp string `json:"timestamp"`
+	Source    string `json:"source"`
+}
+
+type URLQueue struct {
+	mu    sync.Mutex
+	queue []string
+	// No seen map — saves memory. Duplicate URLs are harmless since
+	// we deduplicate by content hash anyway.
+}
+
+func NewURLQueue() *URLQueue {
+	return &URLQueue{
+		queue: make([]string, 0, 100000),
+	}
+}
+
+func (q *URLQueue) Push(u string) bool {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	if len(q.queue) >= MaxQueueSize {
+		return false
+	}
+	q.queue = append(q.queue, u)
+	return true
+}
+
+func (q *URLQueue) PushBulk(urls []string) int {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	added := 0
+	for _, u := range urls {
+		if len(q.queue) < MaxQueueSize {
+			q.queue = append(q.queue, u)
+			added++
+		}
+	}
+	return added
+}
+
+func (q *URLQueue) Pop() (string, bool) {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	if len(q.queue) == 0 {
+		return "", false
+	}
+	u := q.queue[0]
+	q.queue = q.queue[1:]
+	return u, true
+}
+
+func (q *URLQueue) Len() int {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	return len(q.queue)
+}
+
+func (q *URLQueue) Shuffle() {
+	q.mu.Lock()
+	defer q.mu.Unlock()
+	rand.Shuffle(len(q.queue), func(i, j int) {
+		q.queue[i], q.queue[j] = q.queue[j], q.queue[i]
+	})
+}
+
+func isValidURL(rawURL string) bool {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return false
+	}
+	if u.Scheme != "http" && u.Scheme != "https" {
+		return false
+	}
+	if u.Host == "" || !strings.Contains(u.Host, ".") {
+		return false
+	}
+	ext := strings.ToLower(filepath.Ext(u.Path))
+	if blockedExtensions[ext] {
+		return false
+	}
+	if blockedPattern.MatchString(rawURL) {
+		return false
+	}
+	return true
+}
+
+func getDomain(rawURL string) string {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return ""
+	}
+	return u.Host
+}
+
+func contentHash(text string) string {
+	end := len(text)
+	if end > 500 {
+		end = 500
+	}
+	h := md5.Sum([]byte(text[:end]))
+	return hex.EncodeToString(h[:])
+}
+
+func extractText(body string) string {
+	text := tagStripper.ReplaceAllString(body, " ")
+	text = strings.ReplaceAll(text, "&amp;", "&")
+	text = strings.ReplaceAll(text, "&lt;", "<")
+	text = strings.ReplaceAll(text, "&gt;", ">")
+	text = strings.ReplaceAll(text, "&quot;", "\"")
+	text = strings.ReplaceAll(text, "&#39;", "'")
+	text = strings.ReplaceAll(text, "&nbsp;", " ")
+	text = whitespaceCollapse.ReplaceAllString(text, " ")
+	text = strings.TrimSpace(text)
+	return text
+}
+
+func extractLinks(body, baseURL string) []string {
+	var links []string
+	base, err := url.Parse(baseURL)
+	if err != nil {
+		return links
+	}
+	tokenizer := html.NewTokenizer(strings.NewReader(body))
+	for {
+		tt := tokenizer.Next()
+		if tt == html.ErrorToken {
+			break
+		}
+		if tt == html.StartTagToken || tt == html.SelfClosingTagToken {
+			t := tokenizer.Token()
+			if t.Data == "a" {
+				for _, attr := range t.Attr {
+					if attr.Key == "href" {
+						href := strings.TrimSpace(attr.Val)
+						if strings.HasPrefix(href, "#") || strings.HasPrefix(href, "javascript:") {
+							continue
+						}
+						ref, err := url.Parse(href)
+						if err != nil {
+							continue
+						}
+						resolved := base.ResolveReference(ref)
+						resolved.Fragment = ""
+						full := resolved.String()
+						if isValidURL(full) {
+							links = append(links, full)
+						}
+					}
+				}
+			}
+		}
+	}
+	return links
+}
+
+func fetchPage(client *http.Client, rawURL string) (body string, finalURL string, err error) {
+	req, err := http.NewRequest("GET", rawURL, nil)
+	if err != nil {
+		return "", "", err
+	}
+	req.Header.Set("User-Agent", userAgents[rand.Intn(len(userAgents))])
+	req.Header.Set("Accept", "text/html,application/xhtml+xml")
+	req.Header.Set("Accept-Language", "en-US,en;q=0.9")
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return "", "", err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		io.Copy(io.Discard, resp.Body)
+		return "", "", fmt.Errorf("status %d", resp.StatusCode)
+	}
+
+	ct := resp.Header.Get("Content-Type")
+	if !strings.Contains(ct, "text/html") && !strings.Contains(ct, "xhtml") {
+		io.Copy(io.Discard, resp.Body)
+		return "", "", fmt.Errorf("not html: %s", ct)
+	}
+
+	limited := io.LimitReader(resp.Body, 2*1024*1024)
+	data, err := io.ReadAll(limited)
+	if err != nil {
+		return "", "", err
+	}
+
+	return string(data), resp.Request.URL.String(), nil
+}
+
+// ============================================================
+// BULK SEED LOADING — downloads millions of URLs before crawling
+// ============================================================
+
+// downloadCommonCrawlURLs fetches URL lists from Common Crawl's columnar index.
+// CC publishes .gz files listing all crawled URLs per segment.
+func downloadCommonCrawlURLs(queue *URLQueue, targetCount int) int {
+	fmt.Println("[seed] Downloading Common Crawl URL index...")
+	os.MkdirAll(SeedCacheDir, 0755)
+
+	// CC-MAIN-2024-10 cluster.idx lists pages by URL prefix
+	// We download individual WARC path listings and extract URLs
+	// Using the cdx-api to get URL samples across many domains
+	client := &http.Client{Timeout: 60 * time.Second}
+
+	added := 0
+	// Query the CC index API for URLs matching common TLDs
+	// Each query returns up to 15000 results
+	queries := []string{
+		"*.com/*", "*.org/*", "*.net/*", "*.edu/*", "*.gov/*",
+		"*.co.uk/*", "*.io/*", "*.info/*", "*.us/*", "*.ca/*",
+		"*.au/*", "*.de/*", "*.fr/*",
+	}
+
+	for _, q := range queries {
+		if added >= targetCount {
+			break
+		}
+		apiURL := fmt.Sprintf(
+			"https://index.commoncrawl.org/CC-MAIN-2024-10-index?url=%s&output=json&limit=15000&fl=url&filter=languages:eng",
+			url.QueryEscape(q))
+
+		resp, err := client.Get(apiURL)
+		if err != nil {
+			fmt.Printf("[seed] CC query failed for %s: %v\n", q, err)
+			continue
+		}
+
+		scanner := bufio.NewScanner(resp.Body)
+		scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
+		batch := make([]string, 0, 10000)
+		for scanner.Scan() {
+			line := scanner.Text()
+			var rec struct {
+				URL string `json:"url"`
+			}
+			if json.Unmarshal([]byte(line), &rec) == nil && rec.URL != "" && isValidURL(rec.URL) {
+				batch = append(batch, rec.URL)
+				if len(batch) >= 10000 {
+					added += queue.PushBulk(batch)
+					batch = batch[:0]
+				}
+			}
+		}
+		resp.Body.Close()
+		if len(batch) > 0 {
+			added += queue.PushBulk(batch)
+		}
+		fmt.Printf("[seed] CC %s: total queued so far: %d\n", q, queue.Len())
+	}
+	return added
+}
+
+// downloadWikipediaURLs bulk-fetches Wikipedia article URLs via the API
+func downloadWikipediaURLs(queue *URLQueue, count int) int {
+	fmt.Printf("[seed] Fetching %d Wikipedia URLs...\n", count)
+	client := &http.Client{Timeout: 30 * time.Second}
+	added := 0
+	batchSize := 500
+	failures := 0
+	for added < count && failures < 5 {
+		remaining := count - added
+		if remaining > batchSize {
+			remaining = batchSize
+		}
+		resp, err := client.Get(fmt.Sprintf(
+			"https://en.wikipedia.org/w/api.php?action=query&list=random&rnnamespace=0&rnlimit=%d&format=json",
+			remaining))
+		if err != nil {
+			failures++
+			time.Sleep(2 * time.Second)
+			continue
+		}
+		var data struct {
+			Query struct {
+				Random []struct {
+					Title string `json:"title"`
+				} `json:"random"`
+			} `json:"query"`
+		}
+		json.NewDecoder(resp.Body).Decode(&data)
+		resp.Body.Close()
+
+		if len(data.Query.Random) == 0 {
+			failures++
+			continue
+		}
+
+		batch := make([]string, 0, len(data.Query.Random))
+		for _, p := range data.Query.Random {
+			title := strings.ReplaceAll(p.Title, " ", "_")
+			batch = append(batch, "https://en.wikipedia.org/wiki/"+title)
+		}
+		n := queue.PushBulk(batch)
+		added += n
+		if n == 0 {
+			failures++
+		} else {
+			failures = 0
+		}
+		fmt.Printf("[seed] Wikipedia: %d URLs added (total %d)\n", n, added)
+	}
+	return added
+}
+
+// downloadSitemapURLs fetches sitemap.xml from major sites and extracts URLs
+func downloadSitemapURLs(queue *URLQueue) int {
+	fmt.Println("[seed] Fetching sitemaps from major sites...")
+	client := &http.Client{Timeout: 15 * time.Second}
+
+	sitemapSites := []string{
+		"https://www.reuters.com/arc/outboundfeeds/sitemap-index/?outputType=xml",
+		"https://www.bbc.com/sitemaps/https-sitemap-com-news-1.xml",
+		"https://www.theguardian.com/sitemaps/news.xml",
+		"https://www.npr.org/sitemap.xml",
+		"https://arstechnica.com/sitemap.xml",
+		"https://www.wired.com/sitemap.xml",
+		"https://www.theatlantic.com/sitemap.xml",
+		"https://www.vox.com/sitemaps/entries/1",
+		"https://www.nature.com/sitemap.xml",
+		"https://phys.org/sitemap.xml",
+		"https://www.scientificamerican.com/sitemap.xml",
+		"https://www.smithsonianmag.com/sitemap.xml",
+		"https://www.britannica.com/sitemap.xml",
+		"https://www.healthline.com/sitemap.xml",
+		"https://www.investopedia.com/sitemap.xml",
+		"https://www.geeksforgeeks.org/sitemap.xml",
+		"https://realpython.com/sitemap.xml",
+		"https://www.freecodecamp.org/news/sitemap.xml",
+		"https://hackernoon.com/sitemap.xml",
+		"https://dev.to/sitemap.xml",
+		"https://www.history.com/sitemap.xml",
+		"https://www.livescience.com/sitemap.xml",
+		"https://www.space.com/sitemap.xml",
+		"https://www.sciencedaily.com/sitemap.xml",
+		"https://www.psychologytoday.com/sitemap.xml",
+		"https://www.mayoclinic.org/sitemap.xml",
+		"https://medlineplus.gov/sitemap.xml",
+		"https://plato.stanford.edu/sitemap.xml",
+		"https://www.brookings.edu/sitemap.xml",
+		"https://www.rand.org/sitemap.xml",
+	}
+
+	added := 0
+	locRe := regexp.MustCompile(`<loc>([^<]+)</loc>`)
+
+	for _, sitemapURL := range sitemapSites {
+		resp, err := client.Get(sitemapURL)
+		if err != nil {
+			continue
+		}
+		// Only read top-level sitemap (2MB max) — skip sub-sitemaps to save memory
+		body, err := io.ReadAll(io.LimitReader(resp.Body, 2*1024*1024))
+		resp.Body.Close()
+		if err != nil {
+			continue
+		}
+
+		matches := locRe.FindAllSubmatch(body, -1)
+		batch := make([]string, 0, len(matches))
+		for _, m := range matches {
+			u := string(m[1])
+			if isValidURL(u) && !strings.HasSuffix(u, ".xml") && !strings.HasSuffix(u, ".xml.gz") {
+				batch = append(batch, u)
+			}
+		}
+		n := queue.PushBulk(batch)
+		added += n
+		if n > 0 {
+			fmt.Printf("[seed] Sitemap %s: +%d URLs\n", getDomain(sitemapURL), n)
+		}
+	}
+	fmt.Printf("[seed] Sitemaps total: %d URLs added\n", added)
+	return added
+}
+
+func getHNURLs(n int) []string {
+	var urls []string
+	client := &http.Client{Timeout: 10 * time.Second}
+	for _, endpoint := range []string{"topstories", "newstories", "beststories"} {
+		resp, err := client.Get("https://hacker-news.firebaseio.com/v0/" + endpoint + ".json")
+		if err != nil {
+			continue
+		}
+		var ids []int
+		json.NewDecoder(resp.Body).Decode(&ids)
+		resp.Body.Close()
+		if len(ids) > n {
+			ids = ids[:n]
+		}
+		for _, id := range ids {
+			itemResp, err := client.Get(fmt.Sprintf("https://hacker-news.firebaseio.com/v0/item/%d.json", id))
+			if err != nil {
+				continue
+			}
+			var item struct {
+				URL string `json:"url"`
+			}
+			json.NewDecoder(itemResp.Body).Decode(&item)
+			itemResp.Body.Close()
+			if item.URL != "" {
+				urls = append(urls, item.URL)
+			}
+		}
+	}
+	return urls
+}
+
+func uploadChunk(filepath, remoteName string) bool {
+	cmd := exec.Command("python3", "-c", fmt.Sprintf(`
+from huggingface_hub import HfApi
+api = HfApi(token="%s")
+api.upload_file(path_or_fileobj="%s", path_in_repo="data/%s", repo_id="%s", repo_type="dataset")
+print("OK")
+`, HFToken, filepath, remoteName, TargetRepo))
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		fmt.Printf("  Upload failed: %s\n%s\n", err, string(out))
+		return false
+	}
+	fmt.Printf("  Uploaded %s\n", remoteName)
+	return true
+}
+
+func main() {
+	fmt.Println("============================================================")
+	fmt.Println("Go Web Crawler v2 — Bulk-seeded high-throughput crawler")
+	fmt.Printf("Target: %s\n", TargetRepo)
+	fmt.Printf("Workers: %d, Chunk target: ~%.1fGB\n", NumWorkers, float64(ChunkTargetBytes)/1e9)
+	fmt.Println("============================================================")
+
+	os.MkdirAll(OutputDir, 0755)
+
+	// Use connection pooling with higher limits
+	transport := &http.Transport{
+		MaxIdleConns:        300,
+		MaxIdleConnsPerHost: 10,
+		IdleConnTimeout:     30 * time.Second,
+	}
+	client := &http.Client{
+		Timeout:   FetchTimeout,
+		Transport: transport,
+		CheckRedirect: func(req *http.Request, via []*http.Request) error {
+			if len(via) >= 5 {
+				return fmt.Errorf("too many redirects")
+			}
+			return nil
+		},
+	}
+
+	seenHashes := sync.Map{}
+	domainCounts := sync.Map{}
+
+	chunkNum := 0
+	for {
+		name := fmt.Sprintf("crawl_go_chunk%04d.jsonl.gz", chunkNum)
+		if _, err := os.Stat(filepath.Join(OutputDir, name)); os.IsNotExist(err) {
+			break
+		}
+		chunkNum++
+	}
+
+	// ============================================================
+	// PHASE 1: BULK SEED LOADING — fill queue with millions of URLs
+	// ============================================================
+	queue := NewURLQueue()
+
+	fmt.Println("\n=== PHASE 1: Loading seed URLs ===")
+	t0 := time.Now()
+
+	// 1. Common Crawl index — millions of known-good English URLs
+	downloadCommonCrawlURLs(queue, 2_000_000)
+
+	// 2. Wikipedia — 10k random articles (high quality, lots of outlinks)
+	downloadWikipediaURLs(queue, 10000)
+
+	// 3. Sitemaps from major content sites
+	downloadSitemapURLs(queue)
+
+	// 4. HN links
+	for _, u := range getHNURLs(100) {
+		queue.Push(u)
+	}
+
+	elapsed := time.Since(t0)
+	fmt.Printf("\n=== PHASE 1 complete: %d seed URLs loaded in %.0f seconds ===\n\n", queue.Len(), elapsed.Seconds())
+
+	// Shuffle the queue for domain diversity
+	queue.Shuffle()
+
+	// ============================================================
+	// PHASE 2: CRAWL — process URLs and discover new ones
+	// ============================================================
+	fmt.Println("=== PHASE 2: Crawling ===")
+
+	for {
+		if queue.Len() == 0 {
+			fmt.Println("Queue exhausted. Reloading seeds...")
+			downloadCommonCrawlURLs(queue, 500_000)
+			downloadWikipediaURLs(queue, 5000)
+			downloadSitemapURLs(queue)
+			if queue.Len() == 0 {
+				fmt.Println("Cannot refill queue. Waiting 5 min...")
+				time.Sleep(5 * time.Minute)
+				continue
+			}
+		}
+
+		chunkName := fmt.Sprintf("crawl_go_chunk%04d.jsonl.gz", chunkNum)
+		chunkPath := filepath.Join(OutputDir, chunkName)
+
+		f, err := os.Create(chunkPath)
+		if err != nil {
+			fmt.Printf("Error creating chunk: %v\n", err)
+			time.Sleep(30 * time.Second)
+			continue
+		}
+		gzw := gzip.NewWriter(f)
+
+		var writeMu sync.Mutex
+		var chunkBytes int64
+		var chunkDocs int64
+		var pagesTried int64
+		chunkStart := time.Now()
+
+		fmt.Printf("\nStarting chunk %d (%d URLs queued)...\n", chunkNum, queue.Len())
+
+		// Status printer
+		stopStatus := make(chan struct{})
+		go func() {
+			ticker := time.NewTicker(StatusInterval)
+			defer ticker.Stop()
+			for {
+				select {
+				case <-ticker.C:
+					docs := atomic.LoadInt64(&chunkDocs)
+					bytes := atomic.LoadInt64(&chunkBytes)
+					tried := atomic.LoadInt64(&pagesTried)
+					elapsed := time.Since(chunkStart).Seconds()
+					rate := float64(docs) / elapsed
+					fmt.Printf("  Chunk %d: %d docs, %.0fMB, %d queued, %.1f docs/s, tried %d, %.0fs elapsed\n",
+						chunkNum, docs, float64(bytes)/1e6, queue.Len(), rate, tried, elapsed)
+				case <-stopStatus:
+					return
+				}
+			}
+		}()
+
+		// Worker pool
+		urlChan := make(chan string, NumWorkers*4)
+		var wg sync.WaitGroup
+
+		for i := 0; i < NumWorkers; i++ {
+			wg.Add(1)
+			go func() {
+				defer wg.Done()
+				for rawURL := range urlChan {
+					atomic.AddInt64(&pagesTried, 1)
+
+					domain := getDomain(rawURL)
+					if v, ok := domainCounts.Load(domain); ok && v.(int) >= MaxURLsPerDomain {
+						continue
+					}
+
+					body, finalURL, err := fetchPage(client, rawURL)
+					if err != nil {
+						continue
+					}
+
+					text := extractText(body)
+					if len(text) < MinTextLen {
+						continue
+					}
+					if len(text) > MaxTextLen {
+						text = text[:MaxTextLen]
+					}
+
+					h := contentHash(text)
+					if _, loaded := seenHashes.LoadOrStore(h, true); loaded {
+						continue
+					}
+
+					doc := Document{
+						Text:      text,
+						URL:       finalURL,
+						Domain:    domain,
+						Timestamp: time.Now().UTC().Format("2006-01-02T15:04:05Z"),
+						Source:    "crawl_go_v2",
+					}
+					jsonBytes, err := json.Marshal(doc)
+					if err != nil {
+						continue
+					}
+
+					writeMu.Lock()
+					gzw.Write(jsonBytes)
+					gzw.Write([]byte("\n"))
+					atomic.AddInt64(&chunkBytes, int64(len(jsonBytes)))
+					atomic.AddInt64(&chunkDocs, 1)
+					writeMu.Unlock()
+
+					if v, ok := domainCounts.Load(domain); ok {
+						domainCounts.Store(domain, v.(int)+1)
+					} else {
+						domainCounts.Store(domain, 1)
+					}
+
+					// Discover new links from crawled pages
+					links := extractLinks(body, finalURL)
+					rand.Shuffle(len(links), func(i, j int) { links[i], links[j] = links[j], links[i] })
+					maxLinks := 50
+					if len(links) > maxLinks {
+						links = links[:maxLinks]
+					}
+					queue.PushBulk(links)
+				}
+			}()
+		}
+
+		// Feed URLs to workers
+		for atomic.LoadInt64(&chunkBytes) < ChunkTargetBytes {
+			u, ok := queue.Pop()
+			if !ok {
+				// Queue depleted mid-chunk, refill inline
+				fmt.Println("  Queue low, fetching more Wikipedia URLs...")
+				downloadWikipediaURLs(queue, 5000)
+				if queue.Len() == 0 {
+					break
+				}
+				continue
+			}
+			urlChan <- u
+		}
+		close(urlChan)
+		wg.Wait()
+		close(stopStatus)
+
+		gzw.Close()
+		f.Close()
+
+		docs := atomic.LoadInt64(&chunkDocs)
+		bytes := atomic.LoadInt64(&chunkBytes)
+		chunkElapsed := time.Since(chunkStart).Seconds()
+
+		if docs == 0 {
+			fmt.Println("  No docs in chunk, cleaning up")
+			os.Remove(chunkPath)
+			time.Sleep(5 * time.Minute)
+			continue
+		}
+
+		fi, _ := os.Stat(chunkPath)
+		compressedSize := fi.Size()
+		fmt.Printf("  Chunk %d complete: %d docs, %.0fMB raw, %.0fMB compressed, %.0fs, %.1f docs/s\n",
+			chunkNum, docs, float64(bytes)/1e6, float64(compressedSize)/1e6,
+			chunkElapsed, float64(docs)/chunkElapsed)
+
+		if uploadChunk(chunkPath, chunkName) {
+			os.Remove(chunkPath)
+			chunkNum++
+			fmt.Printf("  Total chunks uploaded: %d\n", chunkNum)
+		} else {
+			fmt.Println("  Upload failed, will retry chunk")
+			os.Remove(chunkPath)
+		}
+	}
+}