Download stackgo/stackbuild/repo_extract.py from s0duku/the-stack-go: direct link, hf CLI and curl.
- Browser
- Download file 8.76 kB
-
https://huggingface.co/datasets/s0duku/the-stack-go/resolve/main/stackgo/stackbuild/repo_extract.py
- Command line
-
hf download hf://datasets/s0duku/the-stack-go/stackgo/stackbuild/repo_extract.py
-
curl -L -o repo_extract.py https://huggingface.co/datasets/s0duku/the-stack-go/resolve/main/stackgo/stackbuild/repo_extract.py
8.76 kB
| """Reference extraction backends. | |
| The package uses ``tree-sitter-language-pack`` and keeps a conservative regex | |
| fallback so unsupported or malformed files do not stop a 500k-repository batch. | |
| """ | |
| from __future__ import annotations | |
| from dataclasses import dataclass | |
| import re | |
| from functools import lru_cache | |
| class Reference: | |
| name: str | |
| kind: str | |
| evidence: str | |
| LANG_ALIASES = { | |
| "py": "python", "python": "python", "js": "javascript", | |
| "jsx": "javascript", "ts": "typescript", "tsx": "typescript", | |
| "c": "c", "h": "c", "cc": "cpp", "cpp": "cpp", "cxx": "cpp", | |
| "hpp": "cpp", "go": "go", "java": "java", "cs": "c_sharp", | |
| "rs": "rust", "rb": "ruby", "php": "php", "kt": "kotlin", | |
| "swift": "swift", "c++": "cpp", "c#": "csharp", "c_sharp": "csharp", | |
| "objective-c": "objc", "objective-c++": "objc", "shell": "bash", | |
| "jupyter notebook": "python", "visual basic": "vb", "f#": "fsharp", | |
| } | |
| # This grammar currently calls abort() on some valid input in the native parser, | |
| # which cannot be recovered as a Python exception. Keep these languages on the | |
| # conservative regex backend so one file cannot kill an entire worker process. | |
| UNSAFE_TREESITTER_LANGUAGES = frozenset({"crystal", "lua"}) | |
| PATTERNS: dict[str, tuple[tuple[str, re.Pattern[str]], ...]] = { | |
| "python": (("import", re.compile(r"^\s*import\s+([\w.]+)|^\s*from\s+([\w.]+)\s+import\b", re.M)),), | |
| "javascript": (("import", re.compile(r"(?:import|export)\s+(?:[^;\n]*?\s+from\s+)?[\"']([^\"']+)[\"']|require\(\s*[\"']([^\"']+)[\"']\s*\)", re.M)),), | |
| "typescript": (("import", re.compile(r"(?:import|export)\s+(?:[^;\n]*?\s+from\s+)?[\"']([^\"']+)[\"']|require\(\s*[\"']([^\"']+)[\"']\s*\)", re.M)),), | |
| "c": (("include", re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]", re.M)),), | |
| "cpp": (("include", re.compile(r"^\s*#\s*include\s*[<\"]([^>\"]+)[>\"]", re.M)),), | |
| "go": (("import", re.compile(r"(?:import\s*\(.*?\)|import)\s*[\"']([^\"']+)[\"']", re.S)),), | |
| "java": (("import", re.compile(r"^\s*import\s+(?:static\s+)?([\w.]+)", re.M)),), | |
| "csharp": (("using", re.compile(r"^\s*using\s+(?:static\s+)?([\w.]+)\s*;", re.M)),), | |
| "rust": (("use", re.compile(r"^\s*(?:pub\s+)?(?:use|mod)\s+([\w:]+)", re.M)),), | |
| "swift": (("import", re.compile(r"^\s*import\s+(?:class|struct|enum|protocol|func|var|let)?\s*([A-Za-z_][\w.]*)", re.M)),), | |
| "elixir": (("alias", re.compile(r"^\s*(?:alias|use|import|require)\s+([A-Z][\w.]*)", re.M)),), | |
| "crystal": (("require", re.compile(r"^\s*require\s+[\"']([^\"']+)[\"']", re.M)),), | |
| "lua": (("require", re.compile(r"\brequire\s*(?:\(\s*)?[\"']([^\"']+)[\"']\s*\)?", re.M)),), | |
| } | |
| def _is_parser_failure(error: BaseException) -> bool: | |
| """Catch ordinary parser errors and PyO3 panics, but preserve interrupts.""" | |
| return isinstance(error, Exception) or ( | |
| type(error).__name__ == "PanicException" | |
| and type(error).__module__.startswith("pyo3_runtime") | |
| ) | |
| def language_name(language: str | None, path: str = "") -> str | None: | |
| value = (language or path.rsplit(".", 1)[-1] if (language or "." in path) else "").lower() | |
| return LANG_ALIASES.get(value, value or None) | |
| def regex_references(text: str, language: str | None, path: str = "") -> tuple[Reference, ...]: | |
| lang = language_name(language, path) | |
| found: list[Reference] = [] | |
| for kind, pattern in PATTERNS.get(lang or "", ()): | |
| for match in pattern.finditer(text): | |
| name = next((group for group in match.groups() if group), "") | |
| if name: | |
| found.append(Reference(name, kind, match.group(0).strip()[:240])) | |
| return tuple(found) | |
| def _normalize_ast_import(statement: str, language: str, items: list[str]) -> tuple[Reference, ...]: | |
| """Normalize the language pack's grammar-specific ImportInfo.source.""" | |
| references = regex_references(statement, language) | |
| if references: | |
| if language == "python" and statement.lstrip().startswith("from "): | |
| module = references[0].name | |
| separator = "" if module.endswith(".") else "." | |
| qualified = [Reference(f"{module}{separator}{item}", "import", | |
| f"tree-sitter: {statement[:220]}") | |
| for item in items if item and item != "*"] | |
| if qualified: | |
| return tuple(qualified) | |
| return tuple(Reference(ref.name, ref.kind, f"tree-sitter: {statement[:220]}") for ref in references) | |
| # Some grammars return only a quoted module path instead of a statement. | |
| source = statement.strip().strip("'\"") | |
| if source and not any(char.isspace() for char in source): | |
| return (Reference(source, "import", f"tree-sitter: {statement[:220]}"),) | |
| quoted = re.findall(r"[\"']([^\"']+)[\"']", statement) | |
| if quoted: | |
| return tuple(Reference(value, "import", f"tree-sitter: {statement[:220]}") | |
| for value in quoted) | |
| generic = re.search( | |
| r"(?:^|\s)(?:import|use|using|include|require|mod|load)\s+(?:static\s+)?([\w.:/@+-]+)", | |
| statement, | |
| ) | |
| if generic: | |
| return (Reference(generic.group(1).rstrip(";"), "import", | |
| f"tree-sitter: {statement[:220]}"),) | |
| # Python's ``import x`` may expose imported items separately. | |
| return tuple(Reference(item, "import", f"tree-sitter: {statement[:220]}") for item in items if item) | |
| def _cached_parser(lang: str): | |
| from tree_sitter_language_pack import get_parser | |
| return get_parser(lang) | |
| def _downloaded_languages() -> frozenset[str]: | |
| from tree_sitter_language_pack import downloaded_languages | |
| return frozenset(downloaded_languages()) | |
| def treesitter_references(text: str, language: str | None, path: str = "") -> tuple[Reference, ...] | None: | |
| """Extract references with the optional language pack. | |
| Grammar-specific queries are deliberately not hard-coded here. The | |
| language-independent AST walk confirms that the grammar can parse the file; | |
| language patterns still provide the precise import spelling and a stable | |
| fallback for grammars whose node names vary across versions. | |
| """ | |
| try: | |
| from tree_sitter_language_pack import downloaded_languages | |
| except ImportError: | |
| return None | |
| lang = language_name(language, path) | |
| if not lang: | |
| return None | |
| if lang in UNSAFE_TREESITTER_LANGUAGES: | |
| return None | |
| # The language pack downloads grammars lazily. Never trigger a network | |
| # request from the hot file-scanning loop; callers can prefetch grammars in | |
| # a separate setup step. Missing local grammars use the regex backend. | |
| try: | |
| if lang not in _downloaded_languages(): | |
| return None | |
| # The Rust/PyO3 wrapper can surface a parser panic as a BaseException | |
| # (rather than a normal Exception). A malformed source file must not abort | |
| # an entire repository batch; fall back to the conservative regex parser. | |
| except BaseException as error: | |
| if not _is_parser_failure(error): | |
| raise | |
| return None | |
| try: | |
| from tree_sitter_language_pack import ProcessConfig, process | |
| result = process(text, ProcessConfig( | |
| language=lang, structure=False, imports=True, exports=False, | |
| comments=False, docstrings=False, symbols=False, diagnostics=True, | |
| max_source_bytes=2_000_000, parse_timeout_ms=2_000, | |
| )) | |
| except BaseException as error: | |
| if not _is_parser_failure(error): | |
| raise | |
| return None | |
| found: list[Reference] = [] | |
| for item in result.imports: | |
| found.extend(_normalize_ast_import(item.source, lang, item.items)) | |
| # Not every grammar models dependency constructs as imports (notably | |
| # C/C++ includes). For those languages use the syntax-specific fallback. | |
| if not found and lang in PATTERNS: | |
| return regex_references(text, lang, path) | |
| # Some grammars omit dependency forms from their generic import model: | |
| # JavaScript call-form require() and Rust mod declarations. | |
| if lang in {"javascript", "typescript", "rust"}: | |
| seen = {(ref.name, ref.kind) for ref in found} | |
| found.extend(ref for ref in regex_references(text, lang, path) | |
| if (ref.name, ref.kind) not in seen) | |
| return tuple(found) | |
| def extract_references(text: str, language: str | None, path: str = "", *, | |
| use_treesitter: bool = True) -> tuple[tuple[Reference, ...], str]: | |
| if use_treesitter: | |
| references = treesitter_references(text, language, path) | |
| if references is not None: | |
| return references, "tree-sitter" | |
| return regex_references(text, language, path), "regex" | |