TEI embedding generation for filtering.

.gitignore

@@ -175,3 +175,4 @@ poetry.toml
 
 # LSP config files
 pyrightconfig.json
+data_collection_utils/Top 1000 GitHub repositories, updated daily, all on one page..html

data_collection_utils/embed_repo_descriptions.py

@@ -0,0 +1,352 @@
+#!/usr/bin/env python3
+"""
+Embed GitHub repo short descriptions in batches using a Hugging Face Text Embeddings Inference (TEI)
+server with the Qwen/Qwen3-Embedding-0.6B model, and persist results to Parquet.
+
+Configuration (YAML): place a config file next to this script named
+  embed_repo_descriptions_config.yaml
+
+Example config:
+  tei_url: http://127.0.0.1:8080
+  batch_size: 256
+  timeout: 120
+  output: ../repo_description_embeddings.parquet
+  # Optional: prepend a single custom instruction to each text for models like Qwen3-Embedding
+  # The instruction is applied only to the embedding input as:
+  #   "{instruction}\nQuery: repo name: {name}\n" \
+  #   "description: {text}"
+  # and the original description is preserved in the Parquet output.
+  custom_instruction: "Given a web search query, retrieve relevant passages that answer the query"
+  # Optional custom header for providers like SaladCloud
+  custom_header: Salad-Api-Key
+  custom_header_env: API_KEY  # value will be read from this env var
+  data_sources:
+    - path: data_collection_utils/awesome-repos.parquet
+      source: awesome
+    - path: data_collection_utils/top-1000-repos.parquet
+      source: top1000
+
+Notes:
+- Secrets (e.g., HF_API_TOKEN) should be set in a .env file in the project root or env.
+- Paths in the YAML are resolved relative to the YAML file location.
+
+Output schema (Parquet):
+  - link: string
+  - name: string
+  - description: string
+  - source: string  ('awesome' or 'top1000')
+  - dim: int32      (embedding dimension)
+  - embedding: list<float32>
+
+Notes:
+- This script targets the OpenAI-compatible TEI endpoint: POST {tei_url}/v1/embeddings
+  with payload: {"input": ["text1", ...]}. The model will be whatever TEI is serving.
+- If your TEI requires auth, pass a Bearer token via --hf-token or HF_API_TOKEN env var.
+- Batches are streamed and written incrementally to keep memory bounded.
+- If `custom_instruction` is set, the embedding input becomes:
+    "{custom_instruction}\nQuery: repo name: {repo_name}\ndescription: {original_text}"
+  Only the embedding input is modified; the Parquet `description` column remains the original text.
+"""
+
+from __future__ import annotations
+
+import os
+import argparse
+from pathlib import Path
+from typing import List, Any
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from tqdm import tqdm
+import yaml
+from dotenv import load_dotenv
+from huggingface_hub import InferenceClient
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import requests
+
+
+def _read_parquet_safe(path: Path, source_label: str) -> pd.DataFrame:
+    df = pd.read_parquet(path)
+    # Keep only required columns in a fixed order if present
+    cols = [c for c in ["name", "link", "description"] if c in df.columns]
+    assert "link" in cols and "description" in cols, (
+        f"Expected columns 'link' and 'description' in {path}"
+    )
+    df = df[cols].copy()
+    df["source"] = source_label
+    return df
+
+
+def load_inputs_from_sources(sources: List[Any], cfg_dir: Path) -> pd.DataFrame:
+    parts: List[pd.DataFrame] = []
+    for entry in sources:
+        if isinstance(entry, dict):
+            assert "path" in entry, "Each data_sources item must have a 'path'"
+            p = Path(entry["path"])
+            if not p.is_absolute():
+                p = (cfg_dir / p).resolve()
+            label = entry.get("source") or p.stem
+        else:
+            # allow shorthand string path
+            p = Path(entry)
+            if not p.is_absolute():
+                p = (cfg_dir / p).resolve()
+            label = p.stem
+        assert p.exists(), f"Input parquet not found: {p}"
+        parts.append(_read_parquet_safe(p, label))
+    assert parts, "No input parquet files found via data_sources."
+    df = pd.concat(parts, ignore_index=True)
+    # Filter to non-empty descriptions and deduplicate by link
+    df = df[df["description"].notna()]
+    df = df[df["description"].astype(str).str.strip() != ""]
+    df = df.drop_duplicates(subset=["link"])  # keep first occurrence
+    # Optional: normalize types for consistency
+    if "name" not in df.columns:
+        df["name"] = None
+    df = df[["link", "name", "description", "source"]]
+    return df
+
+
+def embed_batch_tei(
+    client: InferenceClient,
+    model_url: str,
+    texts: List[str],
+) -> Any:
+    # InferenceClient.feature_extraction supports list[str] inputs and returns list[list[float]]
+    embs = client.feature_extraction(texts, model=model_url)
+    # Normalize to List[List[float]]
+    if isinstance(embs, list):
+        assert len(embs) == len(texts) and isinstance(embs[0], (list, tuple)), "Unexpected feature_extraction output"
+        return embs
+    # Otherwise accept numpy arrays (preferred for performance)
+    assert hasattr(embs, "shape"), f"Unexpected feature_extraction type: {type(embs)}"
+    assert embs.shape[0] == len(texts), "Embedding batch size mismatch"
+    return embs
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(
+        description="Batch-embed repo descriptions using TEI and persist to Parquet (YAML-configured)"
+    )
+    ap.add_argument(
+        "--config",
+        default=str(Path(__file__).with_name("embed_repo_descriptions_config.yaml")),
+        help="Path to YAML config (default: next to script)",
+    )
+    ap.add_argument(
+        "--limit",
+        type=int,
+        default=None,
+        help="Optional limit on number of rows for a dry run",
+    )
+    args = ap.parse_args()
+
+    # Load secrets from .env
+    load_dotenv()
+
+    cfg_path = Path(args.config)
+    assert cfg_path.exists(), f"Config not found: {cfg_path}"
+    cfg_dir = cfg_path.parent
+    cfg = yaml.safe_load(cfg_path.read_text(encoding="utf-8")) or {}
+
+    # Required config
+    tei_url = cfg.get("tei_url")
+    assert tei_url, "Missing 'tei_url' in config"
+    data_sources = cfg.get("data_sources")
+    assert isinstance(data_sources, list) and data_sources, (
+        "Config must provide non-empty 'data_sources' list"
+    )
+
+    # Optional config with defaults
+    batch_size = int(cfg.get("batch_size", 256))
+    timeout = int(cfg.get("timeout", 120))
+    concurrency = int(cfg.get("concurrency", 1))
+    assert concurrency >= 1, "concurrency must be >= 1"
+    out_cfg = cfg.get(
+        "output",
+        str(
+            Path(__file__).resolve().parents[1] / "repo_description_embeddings.parquet"
+        ),
+    )
+    out_path = Path(out_cfg)
+    if not out_path.is_absolute():
+        out_path = (cfg_dir / out_path).resolve()
+    # Token is sourced from env (e.g., set via .env)
+    token_env = cfg.get("hf_token_env", "HF_API_TOKEN")
+    hf_token = os.getenv(token_env)
+    # Optional single custom instruction (applied only to embedding input)
+    custom_instruction = cfg.get("custom_instruction")
+    if custom_instruction is not None:
+        assert isinstance(custom_instruction, str) and custom_instruction.strip() != "", (
+            "custom_instruction must be a non-empty string"
+        )
+    # Optional custom header (e.g., Salad-Api-Key)
+    custom_header_name = cfg.get("custom_header")
+    custom_header_env = cfg.get("custom_header_env", "API_KEY")
+    custom_header_value = os.getenv(custom_header_env) if custom_header_name else None
+    if custom_header_name:
+        assert (
+            custom_header_value is not None and custom_header_value != ""
+        ), f"custom_header is set to '{custom_header_name}' but env var '{custom_header_env}' is not set or empty"
+
+    # Build headers for client
+    client_headers = {}
+    if hf_token:
+        client_headers["Authorization"] = f"Bearer {hf_token}"
+    if custom_header_name and custom_header_value:
+        client_headers[custom_header_name] = custom_header_value
+
+    # Health check: ensure TEI is ready before proceeding
+    health_url = tei_url.rstrip("/") + "/health"
+    for i in range(3):
+        resp = requests.get(health_url, headers=client_headers, timeout=timeout)
+        assert resp.status_code == 200, (
+            f"Health check failed on attempt {i+1}/3: {resp.status_code} {resp.text[:200]}"
+        )
+
+    # Compute model URL for embeddings endpoint
+    model_url = tei_url if tei_url.rstrip("/").endswith("/embed") else tei_url.rstrip("/") + "/embed"
+
+    df = load_inputs_from_sources(data_sources, cfg_dir)
+    if args.limit is not None and args.limit > 0:
+        df = df.head(args.limit)
+    # Ensure repo names are present if a custom instruction will join name + description
+    if custom_instruction is not None:
+        assert "name" in df.columns and df["name"].notna().all(), (
+            "When using custom_instruction, 'name' must be present and non-null for all rows"
+        )
+
+    # Prepare Parquet writer with a fixed schema
+    list_float32 = pa.list_(pa.float32())
+    schema = pa.schema(
+        [
+            ("link", pa.string()),
+            ("name", pa.string()),
+            ("description", pa.string()),
+            ("source", pa.string()),
+            ("dim", pa.int32()),
+            ("embedding", list_float32),
+        ]
+    )
+
+    out_path.parent.mkdir(parents=True, exist_ok=True)
+    writer = None
+    try:
+        writer = pq.ParquetWriter(out_path, schema)
+        texts: List[str] = df["description"].astype(str).tolist()
+        links: List[str] = df["link"].astype(str).tolist()
+        # Preserve nulls for name rather than coercing to "None"
+        names: List[Any] = (
+            df["name"].tolist() if "name" in df.columns else [None] * len(df)
+        )
+        sources: List[str] = df["source"].astype(str).tolist()
+
+        dim: int | None = None
+        total_batches = (len(texts) + batch_size - 1) // batch_size
+
+        def _submit_batch(b: int):
+            start = b * batch_size
+            end = min(start + batch_size, len(texts))
+            batch_texts = texts[start:end]
+            batch_names = names[start:end]
+            # Apply instruction formatting for embedding input only
+            embed_batch_texts = (
+                batch_texts
+                if custom_instruction is None
+                else [
+                    f"{custom_instruction}\nQuery: repo name: {n}\ndescription: {t}"
+                    for n, t in zip(batch_names, batch_texts)
+                ]
+            )
+            # Create a per-task client to avoid potential thread-safety issues in shared sessions
+            local_client = InferenceClient(headers=client_headers, timeout=timeout)
+            embs = embed_batch_tei(
+                local_client,
+                model_url,
+                embed_batch_texts,
+            )
+            return b, embs, batch_texts, batch_names, links[start:end], sources[start:end]
+
+        if concurrency == 1:
+            for b in tqdm(range(total_batches), total=total_batches, desc="Embedding", dynamic_ncols=True):
+                b_idx, embs, batch_texts, batch_names, batch_links, batch_sources = _submit_batch(b)
+                if dim is None:
+                    dim = (embs.shape[1] if hasattr(embs, "shape") else len(embs[0]))
+                batch_dims = [dim] * (embs.shape[0] if hasattr(embs, "shape") else len(embs))
+                # Build Arrow arrays
+                arr_link = pa.array(batch_links, type=pa.string())
+                arr_name = pa.array(batch_names, type=pa.string())
+                arr_desc = pa.array(batch_texts, type=pa.string())
+                arr_source = pa.array(batch_sources, type=pa.string())
+                arr_dim = pa.array(batch_dims, type=pa.int32())
+                # Build embeddings Arrow ListArray directly from NumPy for performance
+                embs_np = (
+                    embs.astype(np.float32, copy=False)
+                    if hasattr(embs, "astype")
+                    else np.asarray(embs, dtype=np.float32)
+                )
+                n_rows = embs_np.shape[0]
+                offsets = pa.array(np.arange(0, (n_rows + 1) * dim, dim, dtype=np.int32))
+                values = pa.array(embs_np.reshape(-1), type=pa.float32())
+                arr_emb = pa.ListArray.from_arrays(offsets, values, type=list_float32)
+                table = pa.Table.from_arrays(
+                    [arr_link, arr_name, arr_desc, arr_source, arr_dim, arr_emb],
+                    schema=schema,
+                )
+                writer.write_table(table)
+        else:
+            with ThreadPoolExecutor(max_workers=concurrency) as ex:
+                with tqdm(total=total_batches, desc="Embedding", dynamic_ncols=True) as pbar:
+                    next_to_submit = 0
+                    futures = []
+                    # Prime the executor with up to `concurrency` tasks
+                    while next_to_submit < min(concurrency, total_batches):
+                        futures.append(ex.submit(_submit_batch, next_to_submit))
+                        next_to_submit += 1
+                    pbar.set_postfix(inflight=len(futures), submitted=next_to_submit, refresh=True)
+                    # As each future completes, write results and submit the next batch
+                    while futures:
+                        for fut in as_completed(futures, timeout=None):
+                            futures.remove(fut)
+                            b_idx, embs, batch_texts, batch_names, batch_links, batch_sources = fut.result()
+                            if dim is None:
+                                dim = (embs.shape[1] if hasattr(embs, "shape") else len(embs[0]))
+                            batch_dims = [dim] * (embs.shape[0] if hasattr(embs, "shape") else len(embs))
+                            arr_link = pa.array(batch_links, type=pa.string())
+                            arr_name = pa.array(batch_names, type=pa.string())
+                            arr_desc = pa.array(batch_texts, type=pa.string())
+                            arr_source = pa.array(batch_sources, type=pa.string())
+                            arr_dim = pa.array(batch_dims, type=pa.int32())
+                            embs_np = (
+                                embs.astype(np.float32, copy=False)
+                                if hasattr(embs, "astype")
+                                else np.asarray(embs, dtype=np.float32)
+                            )
+                            n_rows = embs_np.shape[0]
+                            offsets = pa.array(np.arange(0, (n_rows + 1) * dim, dim, dtype=np.int32))
+                            values = pa.array(embs_np.reshape(-1), type=pa.float32())
+                            arr_emb = pa.ListArray.from_arrays(offsets, values, type=list_float32)
+                            table = pa.Table.from_arrays(
+                                [arr_link, arr_name, arr_desc, arr_source, arr_dim, arr_emb],
+                                schema=schema,
+                            )
+                            writer.write_table(table)
+                            pbar.update(1)
+                            # Submit next batch if any remain
+                            if next_to_submit < total_batches:
+                                futures.append(ex.submit(_submit_batch, next_to_submit))
+                                next_to_submit += 1
+                            pbar.set_postfix(inflight=len(futures), submitted=next_to_submit, refresh=True)
+                            # Break to re-enter as_completed with the updated futures list
+                            break
+    finally:
+        if writer is not None:
+            writer.close()
+
+    print(f"Wrote embeddings for {len(df)} repos to {out_path}")
+
+
+if __name__ == "__main__":
+    main()

data_collection_utils/embed_repo_descriptions_config.yaml

@@ -0,0 +1,47 @@
+# Configuration for embed_repo_descriptions.py
+# Paths are resolved relative to this file's directory
+
+tei_url: https://mayonaise-mushroom-d1nbuod55i4as9x1.salad.cloud
+model: tei
+batch_size: 128
+timeout: 180
+## Number of parallel requests to the TEI endpoint. Increase if your endpoint supports concurrency.
+## Set to 1 to run sequentially.
+concurrency: 4
+output: ../repo_description_embeddings.parquet
+
+# Optional: prepend a single custom instruction to each text for models like Qwen3-Embedding.
+# Applied only to embedding inputs:
+#   "{instruction}\nQuery: repo name: {name}\ndescription: {text}"
+custom_instruction: |
+  Instruction: Produce an embedding vector that captures how much a GitHub repository is relevant to developer tooling, libraries, frameworks, or developer-focused documentation. Repositories unrelated to software development (like general ebooks, personal projects, or end-user applications) should have embeddings that are distant in vector space.
+
+  Context: Use the repository name and description to assess relevance.
+
+  Guidelines:
+  - Positive examples (should be considered developer tooling):
+    1. "The library for web and native user interfaces." (facebook/react)
+    2. "A modern build tool to bundle JavaScript applications." (vitejs/vite)
+    3. "A Python framework for building web APIs quickly." (tiangolo/fastapi)
+
+  - Negative examples (should be considered irrelevant):
+    1. "📚 Freely available programming books." (EbookFoundation/free-programming-books)
+    2. "Collection of funny memes." (someuser/memes)
+    3. "Personal finance tracker app." (someuser/fintrack)
+
+  Task: Return an embedding vector that represents the repository’s relevance to developer tools and developer-focused documentation.
+
+
+# Environment variable name to read the Hugging Face/TEI token from
+hf_token_env: HF_API_TOKEN
+
+# Optional custom provider header (e.g., SaladCloud)
+# The header value will be read from the environment variable named in custom_header_env
+custom_header: Salad-Api-Key
+custom_header_env: API_KEY
+
+data_sources:
+  - path: ./awesome-repos.parquet
+    source: awesome
+  # - path: ./top-1000-repos.parquet
+  #   source: top1000

data_collection_utils/top_1000_repos.py

@@ -1,7 +1,9 @@
 from pathlib import Path
 from playwright.sync_api import sync_playwright
 from urllib.parse import urlparse
-from typing import List, Optional
+from typing import List, Optional, Dict, Any
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import argparse
 import pandas as pd
 from github_api_utils import get_repo_info
 
@@ -81,10 +83,18 @@ def map_to_original_repos(urls: List[str]) -> List[str]:
         o = resolve_to_original_repo(u)
         if o is not None:
             originals.add(o)
+        else:
+            # keep the canonical URL if we couldn't resolve
+            cu = canonical_repo_url(u) or u
+            originals.add(cu)
     return sorted(originals)
 
 
 def main() -> None:
+    ap = argparse.ArgumentParser(description="Fetch Top 1000 repos and enrich via GitHub API")
+    ap.add_argument("--workers", type=int, default=16, help="Concurrency for GitHub API requests")
+    args = ap.parse_args()
+
     project_root = Path(__file__).resolve().parents[1]
     out_html = Path(__file__).with_name(
         "Top 1000 GitHub repositories, updated daily, all on one page..html"
@@ -100,87 +110,76 @@ def main() -> None:
         # Wait until at least one GitHub link is present in the DOM
         page.wait_for_selector('a[href*="https://github.com/"]', timeout=30000)
 
+        # Auto-scroll to force lazy loading/virtualized list to render all items
+        def _scroll_all(max_iters: int = 200, pause_ms: int = 300) -> None:
+            prev_count = 0
+            stable = 0
+            for _ in range(max_iters):
+                page.evaluate("window.scrollTo(0, document.body.scrollHeight)")
+                page.wait_for_timeout(pause_ms)
+                count = page.eval_on_selector_all(
+                    'a[href^="https://github.com/"]', 'els => els.length'
+                )
+                if count <= prev_count:
+                    stable += 1
+                else:
+                    stable = 0
+                    prev_count = count
+                # Stop after several iterations without growth or when clearly above 1000 anchors
+                if stable >= 10 or prev_count >= 1500:
+                    break
+
+        _scroll_all()
+
         # Save rendered HTML
         html = page.content()
         out_html.write_text(html, encoding="utf-8")
 
-        # Extract structured repo data from the rendered DOM
-        items = page.eval_on_selector_all(
-            'a[href^="https://github.com/"]',
-            r'''
-els => {
-  const seen = new Map();
-  function canonical(u) {
-    try {
-      const url = new URL(u);
-      const parts = url.pathname.split('/').filter(Boolean);
-      if (url.hostname !== 'github.com' || parts.length < 2) return null;
-      return `https://github.com/${parts[0]}/${parts[1]}`;
-    } catch { return null; }
-  }
-  function extractCardInfo(a) {
-    const cu = canonical(a.href);
-    if (!cu) return null;
-    let container = a.closest('li, article, .repo, .card, .row, .item, .entry, .col') || a.parentElement;
-    if (!container) container = a;
-    const name = (a.textContent || '').trim();
-    // description: first <p> with reasonable length
-    let desc = '';
-    const ps = container.querySelectorAll('p');
-    for (const p of ps) {
-      const t = (p.textContent || '').trim();
-      if (t.length >= 10 && t.length <= 300) { desc = t; break; }
-    }
-    // stars: prefer contexts with star symbol or 'stars'
-    let stars = null;
-    const text = container.textContent || '';
-    const m1 = text.match(/([0-9][0-9,._]*)\s*(★|⭐|stars?)/i);
-    if (m1) {
-      stars = parseInt(m1[1].replace(/[,_\.]/g, ''), 10);
-    } else {
-      const matches = Array.from(text.matchAll(/\b\d{1,3}(?:,\d{3})+|\b\d{2,6}\b/g));
-      if (matches.length) {
-        const nums = matches.map(m => parseInt(m[0].replace(/,/g, ''), 10)).filter(n => !Number.isNaN(n));
-        if (nums.length) stars = Math.max(...nums);
-      }
-    }
-    return { name, link: cu, description: desc, stars };
-  }
-  for (const a of els) {
-    const info = extractCardInfo(a);
-    if (!info) continue;
-    if (seen.has(info.link)) continue;
-    seen.set(info.link, info);
-  }
-  return Array.from(seen.values());
-}
-''',
+        # Extract canonical GitHub repo URLs from the DOM after full scroll
+        links = page.eval_on_selector_all(
+            'a[href*="https://github.com/"]',
+            "els => Array.from(new Set(els.map(e => e.href))).sort()",
+        )
+        repo_links = normalize_github_repo_links(links)
+
+        # Optionally map any fork links to their original repositories and deduplicate
+        repo_links = map_to_original_repos(repo_links)
+
+        # Persist github_links.txt for visibility/debug (even if not used downstream)
+        with out_links.open("w", encoding="utf-8") as f:
+            f.write("\n".join(repo_links) + "\n")
+
+        # Enrich via GitHub API concurrently
+        def _one(url: str) -> Dict[str, Any]:
+            owner_repo = urlparse(url).path.strip("/").split("/")[:2]
+            owner, repo = owner_repo[0], owner_repo[1]
+            info = get_repo_info(owner, repo) or {}
+            name = info.get("name") or repo
+            desc = info.get("description") or None
+            stars = info.get("stargazers_count")
+            return {
+                "name": name,
+                "link": f"https://github.com/{owner}/{repo}",
+                "description": desc,
+                "stars": int(stars) if isinstance(stars, int) else None,
+            }
+
+        rows: List[Dict[str, Any]] = []
+        with ThreadPoolExecutor(max_workers=args.workers) as ex:
+            futs = [ex.submit(_one, u) for u in repo_links]
+            for fut in as_completed(futs):
+                try:
+                    rows.append(fut.result())
+                except Exception:
+                    # Skip on error; we aim for stability over strict completeness
+                    continue
+
+        df = pd.DataFrame(rows)
+        df.to_parquet(out_parquet, index=False)
+        print(f"Wrote HTML to {out_html}")
+        print(
+            f"Saved {len(df)} repos to {out_parquet} and links ({len(repo_links)}) to {out_links}"
         )
-
-        # Persist Parquet with schema: name, link, description, stars
-        df = pd.DataFrame(items)
-        # Fallback: if items list is empty, keep legacy behavior to at least emit links
-        if df.empty:
-            links = page.eval_on_selector_all(
-                'a[href*="https://github.com/"]',
-                "els => Array.from(new Set(els.map(e => e.href))).sort()",
-            )
-            repo_links = normalize_github_repo_links(links)
-            repo_links = map_to_original_repos(repo_links)
-            with out_links.open("w", encoding="utf-8") as f:
-                f.write("\n".join(repo_links) + "\n")
-            print(f"Wrote HTML to {out_html}")
-            print(
-                f"Found {len(repo_links)} original GitHub repositories and saved to {out_links}"
-            )
-        else:
-            # Also emit github_links.txt for compatibility
-            repo_links = sorted({u for u in df["link"].tolist()})
-            with out_links.open("w", encoding="utf-8") as f:
-                f.write("\n".join(repo_links) + "\n")
-            df.to_parquet(out_parquet, index=False)
-            print(f"Wrote HTML to {out_html}")
-            print(f"Saved {len(df)} repos to {out_parquet} and links to {out_links}")
 
         context.close()
         browser.close()

requirements.txt

@@ -7,4 +7,6 @@ langid
 playwright
 duckdb
 aiohttp
-python-dotenv
+python-dotenv
+huggingface_hub
+numpy