| """Normalize heterogeneous repository files into model-readable text.""" |
|
|
| from __future__ import annotations |
|
|
| import json |
| from pathlib import PurePosixPath |
|
|
| from .repo import RepoFile |
|
|
|
|
| NOTEBOOK_SUFFIXES = {".ipynb"} |
| MARKDOWN_SUFFIXES = {".md", ".mdx", ".markdown", ".rst", ".adoc"} |
|
|
|
|
| def normalized_path(path: str) -> str: |
| return PurePosixPath(path).as_posix().lstrip("/") |
|
|
|
|
| def decoded_content(file: RepoFile) -> str: |
| if isinstance(file.content, str): |
| return file.content |
| return file.content.decode(file.encoding or "utf-8", errors="replace") |
|
|
|
|
| def is_binary(file: RepoFile) -> bool: |
| if isinstance(file.content, str): |
| return False |
| head = file.content[:8192] |
| if b"\x00" in head: |
| return True |
| if not head: |
| return False |
| control = sum(byte < 9 or 13 < byte < 32 for byte in head) |
| return control / len(head) > 0.05 |
|
|
|
|
| def file_role(file: RepoFile) -> str: |
| path = normalized_path(file.path) |
| name = PurePosixPath(path).name.lower() |
| suffix = PurePosixPath(path).suffix.lower() |
| if is_binary(file): |
| return "binary" |
| if suffix in NOTEBOOK_SUFFIXES: |
| return "notebook" |
| if suffix in MARKDOWN_SUFFIXES or name.startswith("readme"): |
| return "documentation" |
| if name in {"makefile", "cmakelists.txt", "build.gradle", "build.gradle.kts", "pom.xml"}: |
| return "build" |
| if name in {"package.json", "pyproject.toml", "cargo.toml", "go.mod", "composer.json"}: |
| return "manifest" |
| return "source" if file.language else "unknown" |
|
|
|
|
| def notebook_text(file: RepoFile) -> str | None: |
| """Render a notebook as an ordered cell stream; return None if malformed.""" |
| try: |
| data = json.loads(decoded_content(file)) |
| except (json.JSONDecodeError, TypeError, UnicodeError): |
| return None |
| cells = data.get("cells") |
| if not isinstance(cells, list): |
| return None |
| rendered: list[str] = [] |
| for cell in cells: |
| if not isinstance(cell, dict): |
| continue |
| kind = cell.get("cell_type") |
| source = cell.get("source", "") |
| if isinstance(source, list): |
| source = "".join(part for part in source if isinstance(part, str)) |
| if not isinstance(source, str): |
| continue |
| if kind == "markdown": |
| rendered.append("# Cell: Markdown\n" + source.rstrip()) |
| elif kind == "code": |
| rendered.append("# Cell: Code\n" + source.rstrip()) |
| outputs = cell.get("outputs") |
| if isinstance(outputs, list) and outputs: |
| output = _notebook_output(outputs[-1]) |
| if output: |
| rendered.append("# Cell: Output\n" + output.rstrip()) |
| return "\n".join(rendered).rstrip() + ("\n" if rendered else "") |
|
|
|
|
| def _notebook_output(output: object) -> str: |
| if not isinstance(output, dict): |
| return "" |
| value = output.get("text") |
| if value is None and isinstance(output.get("data"), dict): |
| value = output["data"].get("text/plain") |
| if isinstance(value, list): |
| return "".join(part for part in value if isinstance(part, str)) |
| return value if isinstance(value, str) else "" |
|
|
|
|
| def training_content(file: RepoFile, config) -> tuple[str, str, str]: |
| """Return rendered content, policy, and role for one file.""" |
| role = file_role(file) |
| if role == "binary": |
| return "", "metadata_only", role |
| if file.is_vendor and config.metadata_only_vendor: |
| return "", "metadata_only", role |
| if file.is_generated and config.metadata_only_generated: |
| return "", "metadata_only", role |
| if role == "notebook": |
| rendered = notebook_text(file) |
| if rendered is not None: |
| return rendered, "structured", role |
| return decoded_content(file), "full", role |
|
|
