(optim) faster rebuild

clean/clean_docs_using_content.py

@@ -26,7 +26,7 @@ if __name__ == "__main__":
     -- Step 1: Filter the base data (filename column is precomputed)
     WITH filtered AS (
         SELECT *
-        FROM 'texts.parquet'
+        FROM 'output/texts.parquet'
         WHERE {conditions_str}
     ),
     -- Step 2: Rank by mtime within each (owner, repo, filename) group to identify latest versions

clean/data_stats.py

@@ -2,7 +2,7 @@ import duckdb
 
 if __name__ == "__main__":
     # Set source file: 'texts.parquet' or 'gooddocs.parquet'
-    source_file = "texts.parquet"
+    source_file = "output/texts.parquet"
 
     # Query to filter repos with more than 100 docs and fetch their README.md
     query = f"""

data_collection_utils/fetch_gh_meta.py

@@ -162,7 +162,7 @@ def main():
 
     # Fetch in batches via GraphQL
     records: List[Dict[str, Any]] = []
-    run_ts = datetime.now(datetime.timezone.utc).isoformat()
+    run_ts = datetime.utcnow().isoformat()
     for i in tqdm(range(0, len(pairs), batch_size), desc="GraphQL batches"):
         batch = pairs[i : i + batch_size]
         meta = fetch_repos_metadata_graphql(batch)

data_collection_utils/scrape_gh_docs.py

@@ -159,23 +159,46 @@ def collect_md_rows_for_repo_dir(
     except ValueError:
         return []
     rows: List[Dict[str, Any]] = []
-    for md_file in d.rglob("*.md"):
-        if not md_file.is_file():
+    # Collect candidate files:
+    #  - All Markdown files (*.md) under repo dir
+    #  - Plus README files at repo root with any extension (README, README.md, README.rst, etc.)
+    candidates: List[Path] = []
+    candidates.extend(d.rglob("*.md"))
+    # Add root-level README variants (case-insensitive)
+    for p in d.iterdir():
+        if p.is_file() and p.name.lower().startswith("readme"):
+            candidates.append(p)
+    # Deduplicate while preserving order
+    seen_paths = set()
+    unique_candidates: List[Path] = []
+    for p in candidates:
+        rp = p.resolve()
+        if rp in seen_paths:
+            continue
+        seen_paths.add(rp)
+        unique_candidates.append(p)
+
+    for fpath in unique_candidates:
+        if not fpath.is_file():
             continue
         try:
-            rel_repo = md_file.relative_to(d)
+            rel_repo = fpath.relative_to(d)
         except Exception:
-            rel_repo = md_file.name
-        text = md_file.read_text(encoding="utf-8", errors="replace")
+            rel_repo = fpath.name
+        text = fpath.read_text(encoding="utf-8", errors="replace")
         lang_code = None
         include = True
-        if len(text) >= min_text_chars_value:
-            lid_code, _ = langid.classify(text)
-            lang_code = lid_code
-            if lang_filter_value is not None and str(lang_filter_value).strip() != "":
+        # Always include README files regardless of length/language
+        is_readme = fpath.parent == d and fpath.name.lower().startswith("readme")
+        should_filter_lang = (
+            lang_filter_value is not None and str(lang_filter_value).strip() != ""
+        )
+        if not is_readme and should_filter_lang:
+            if len(text) >= min_text_chars_value:
+                lid_code, _ = langid.classify(text)
+                lang_code = lid_code
                 include = lang_code == lang_filter_value
-        else:
-            if lang_filter_value is not None and str(lang_filter_value).strip() != "":
+            else:
                 include = False
         if include:
             row = {
@@ -183,9 +206,9 @@ def collect_md_rows_for_repo_dir(
                 "repo": repo,
                 "repo_dir": d.name,
                 "file_rel_repo": str(rel_repo),
-                "file_rel_outdir": str(md_file.relative_to(outdir)),
-                "size": md_file.stat().st_size,
-                "mtime": int(md_file.stat().st_mtime),
+                "file_rel_outdir": str(fpath.relative_to(outdir)),
+                "size": fpath.stat().st_size,
+                "mtime": int(fpath.stat().st_mtime),
                 "lang": lang_code,
                 "content": text,
                 "updated_at": updated_at,
@@ -885,6 +908,7 @@ def main():
     no_fetch_value = bool(args.no_fetch or cfg.get("no_fetch", False))
     lang_filter_value = cfg.get("lang_filter", "en")
     min_text_chars_value = int(cfg.get("min_text_chars", 200))
+    postprocess_executor_value = str(cfg.get("postprocess_executor", "thread")).lower()
 
     def _resolve_cfg_paths(val):
         if val is None:
@@ -911,6 +935,7 @@ def main():
     )
     con = duckdb.connect(str(duckdb_path))
     _init_duckdb(con)
+    logger.info(f"Opened DuckDB at '{duckdb_path}'")
 
     md_failed_path = Path(md_failed_value)
     # create/empty md_failed file
@@ -952,6 +977,7 @@ def main():
                     seen_raw_invalid.add(s)
                     lines.append(s)
 
+    logger.info(f"Will process {len(lines)} repo entries (fetch={'off' if no_fetch_value else 'on'})")
     # Initialize locks for thread-safe writes and results accumulation
     md_failed_lock = threading.Lock()
     results_lock = threading.Lock()
@@ -959,7 +985,7 @@ def main():
     duckdb_lock = threading.Lock()
 
     # Process repositories concurrently
-    run_ts = datetime.now(datetime.timezone.utc).isoformat()
+    run_ts = datetime.utcnow().isoformat()
     with tqdm(total=len(lines), desc="Repos") as pbar:
 
         def _run(lr: str):
@@ -1017,6 +1043,7 @@ def main():
                                     )
                                     con.unregister("df_txt_one")
                                     con.execute("COMMIT")
+                                logger.info(f"[incremental] {owner}/{repo}: inserted {len(rows_one)} rows into DuckDB")
             except Exception as e:
                 logger.error(f"Exception while processing {lr}: {e}")
                 append_line_threadsafe(
@@ -1054,6 +1081,7 @@ def main():
         for d in outdir.iterdir()
         if d.is_dir() and "__" in d.name and not d.name.startswith("tmp_")
     ]
+    logger.info(f"Starting post-processing scan of {len(repo_dirs)} repos under '{outdir}' to rebuild per-file dataset")
     # Rebuild texts table from filesystem by streaming per-repo inserts into DuckDB
     cols = [
         "owner",
@@ -1068,12 +1096,19 @@ def main():
         "updated_at",
     ]
     total_inserted = 0
+    logger.info("Clearing DuckDB 'texts' table for full rebuild")
     with duckdb_lock:
         con.execute("DELETE FROM texts")
     with tqdm(total=len(repo_dirs), desc="Collecting per-file rows (repos)") as pbar:
-        with concurrent.futures.ThreadPoolExecutor(
-            max_workers=workers_value
-        ) as executor:
+        executor_cls = (
+            concurrent.futures.ProcessPoolExecutor
+            if postprocess_executor_value == "process"
+            else concurrent.futures.ThreadPoolExecutor
+        )
+        logger.info(
+            f"Post-processing executor: {executor_cls.__name__} with workers={workers_value}"
+        )
+        with executor_cls(max_workers=workers_value) as executor:
             futures = [
                 executor.submit(
                     collect_md_rows_for_repo_dir,
@@ -1098,6 +1133,7 @@ def main():
                         con.execute("INSERT INTO texts SELECT * FROM df_txt_chunk")
                         con.unregister("df_txt_chunk")
                     total_inserted += len(rows)
+                    pbar.set_postfix_str(f"rows={total_inserted}")
                 pbar.update(1)
 
     # Export texts from DuckDB to Parquet
@@ -1106,9 +1142,11 @@ def main():
     )
     try:
         texts_parquet_path.parent.mkdir(parents=True, exist_ok=True)
+        logger.info(f"Exporting DuckDB 'texts' table to Parquet at '{texts_parquet_path}' ...")
+        # DuckDB does not support parameter binding for COPY target; embed the path directly
+        out_path_sql = str(texts_parquet_path).replace("'", "''")
         con.execute(
-            "COPY (SELECT * FROM texts) TO ? (FORMAT PARQUET)",
-            [str(texts_parquet_path)],
+            f"COPY (SELECT * FROM texts) TO '{out_path_sql}' (FORMAT PARQUET)"
         )
         logger.info(
             f"Wrote per-file dataset to {texts_parquet_path} (rows={total_inserted})"