"""End-to-end DeepSeek-style repository training sample construction.""" from __future__ import annotations import hashlib import math from collections import OrderedDict, deque from typing import Callable from .content import normalized_path, training_content from .graph import dependency_components from .model import ( BEGIN_FILE, BEGIN_FILE_NAME, BEGIN_REPO_NAME, END_FILE, END_FILE_NAME, END_REPO_NAME, BuildConfig, Sample, SampleFile, ) from .repo import Repo, RepoFile, RepoInfo, scan from .tokenizer import load_tokenizer TokenCounter = Callable[[str], int] class _Counter: def __init__(self, tokenizer=None, utf8_bytes_per_token: float = 3.0): self.tokenizer = tokenizer self.utf8_bytes_per_token = utf8_bytes_per_token self.mode = (f"utf8_estimate_{utf8_bytes_per_token:g}bytes_per_token" if tokenizer is None else "tokens") self._cache: OrderedDict[str, int] = OrderedDict() def __call__(self, text: str) -> int: if text in self._cache: self._cache.move_to_end(text) return self._cache[text] if self.tokenizer is None: byte_count = len(text.encode("utf-8")) value = math.ceil(byte_count / self.utf8_bytes_per_token) else: encode = getattr(self.tokenizer, "encode", None) if encode is not None: try: value = len(encode(text, add_special_tokens=False)) except TypeError: try: value = len(encode(text, disallowed_special=())) except TypeError: value = len(encode(text)) elif callable(self.tokenizer): result = self.tokenizer(text) value = result if isinstance(result, int) else len(result) else: raise TypeError("tokenizer must be callable or provide encode()") self._cache[text] = value if len(self._cache) > 128: self._cache.popitem(last=False) return value def build_samples(repo: Repo, *, config: BuildConfig | None = None, tokenizer=None, info: RepoInfo | None = None, use_treesitter: bool = True) -> tuple[Sample, ...]: """Analyze ``repo`` and return deterministic, budgeted training samples.""" config = config or BuildConfig() tokenizer = tokenizer or load_tokenizer() counter = _Counter(tokenizer, config.utf8_bytes_per_token) repo_files = tuple(repo.iter_files()) snapshot = Repo(repo.repo_id, repo.revision_id, repo_files) info = info or scan( snapshot, include_weak=config.include_weak_edges, use_treesitter=use_treesitter, ) files = {normalized_path(file.path): file for file in repo_files} if len(files) != len(repo_files): raise ValueError("Repo contains duplicate normalized file paths") if set(files) != {file.path for file in info.files}: raise ValueError("RepoInfo does not describe the supplied Repo snapshot") rendered = { path: training_content(file, config) for path, file in files.items() } samples = _dependency_samples(snapshot, info, rendered, config, counter) if config.target_context: samples.extend(_target_context_samples(snapshot, info, rendered, config, counter, samples)) return tuple(samples) def _repository_header(repo: Repo) -> str: return f"{BEGIN_REPO_NAME}{repo.repo_id}{END_REPO_NAME}\n" def _file_block(path: str, content: str, policy: str, role: str, *, part: int = 1, parts: int = 1) -> str: suffix = f" (part {part}/{parts})" if parts > 1 else "" lines = [f"{BEGIN_FILE_NAME}{path}{suffix}{END_FILE_NAME}", BEGIN_FILE] if content: lines.append(content.rstrip()) lines.append(END_FILE) return "\n".join(lines) + "\n" def _chunks(path: str, content: str, policy: str, role: str, language: str | None, budget: int, counter: TokenCounter) -> tuple[str, ...]: if not content: return ("",) # Avoid sending multi-megabyte source files through the tokenizer several # times. Besides being quadratic in the old binary search, concurrent huge # encodes can exhaust system memory. Normal files still take the fast path. max_candidate_chars = 262_144 if (len(content) <= max_candidate_chars and counter(_file_block(path, content, policy, role)) <= budget): return (content,) # Splitting adds a part=i/n descriptor. Reserve its worst practical width # while finding boundaries so the final rendered blocks remain in budget. def split_block(value: str) -> str: return _file_block(path, value, policy, role, part=999_999, parts=999_999) units: list[str] = [] unit_chars = 16_384 for line in content.splitlines(keepends=True): units.extend(line[start:start + unit_chars] for start in range(0, len(line), unit_chars)) if not units and content: units = [content] def exact_split(parts: list[str]) -> list[str]: chunks: list[str] = [] current = "" for unit in parts: candidate = current + unit if (len(candidate) <= max_candidate_chars and counter(split_block(candidate)) <= budget): current = candidate continue if current: chunks.append(current) current = "" while unit: if counter(split_block(unit)) <= budget: current = unit break lo, hi, chars = 1, len(unit), 0 while lo <= hi: middle = (lo + hi) // 2 if counter(split_block(unit[:middle])) <= budget: chars = middle lo = middle + 1 else: hi = middle - 1 if not chars: raise ValueError(f"max_tokens is too small for file metadata: {path}") chunks.append(unit[:chars]) unit = unit[chars:] if current: chunks.append(current) return chunks chunks: list[str] = [] start = 0 while start < len(units): # Find the largest exact unit prefix that fits. This preserves the old # greedy boundaries while replacing O(units) repeated encodes with # O(log units) encodes per output chunk. low, high, best = 1, len(units) - start, 0 while low <= high: middle = (low + high) // 2 candidate = "".join(units[start:start + middle]) if (len(candidate) <= max_candidate_chars and counter(split_block(candidate)) <= budget): best = middle low = middle + 1 else: high = middle - 1 if best: chunks.append("".join(units[start:start + best])) start += best continue chunks.extend(exact_split([units[start]])) start += 1 return tuple(chunks) def _dependency_samples(repo, info, rendered, config, counter) -> list[Sample]: samples: list[Sample] = [] language_by_path = {file.path: file.language for file in info.files} components = dependency_components(info) linked = [component for component in components if len(component) > 1] isolated_set = {component[0] for component in components if len(component) == 1} isolated = tuple(path for path in info.topological_order if path in isolated_set) groups = linked + ([isolated] if isolated else []) header = _repository_header(repo) header_tokens = counter(header) file_budget = config.max_tokens - header_tokens if file_budget < 1: raise ValueError("max_tokens is too small for repository metadata") if config.max_file_tokens is not None: file_budget = min(file_budget, config.max_file_tokens) for component_index, component in enumerate(groups): entries: list[tuple[str, str, str, str, str | None, int, int]] = [] for path in component: content, policy, role = rendered[path] language = language_by_path[path] parts = _chunks(path, content, policy, role, language, file_budget, counter) entries.extend((path, part, policy, role, language, index, len(parts)) for index, part in enumerate(parts, 1)) pack: list[tuple[str, str, str, str, str | None, int, int]] = [] pack_text = "" used = 0 def flush() -> None: nonlocal pack, pack_text, used text = header + pack_text token_count = counter(text) if token_count > config.max_tokens: raise ValueError( f"dependency sample exceeds max_tokens for {repo.repo_id}: {token_count}" ) sample = _make_dependency( repo, info, samples, pack, component_index, counter, text=text, token_count=token_count, ) if sample.token_count >= config.min_tokens: samples.append(sample) pack, pack_text, used = [], "", 0 for entry in entries: block = _file_block(entry[0], entry[1], entry[2], entry[3], part=entry[5], parts=entry[6]) cost = counter(block) if pack and header_tokens + used + cost > config.max_tokens: flush() pack.append(entry) pack_text += block used += cost if header_tokens + cost > config.max_tokens: raise ValueError(f"file block exceeds max_tokens: {entry[0]}") if pack: flush() return samples def _make_dependency(repo, info, existing, entries, component_index, counter, *, text: str | None = None, token_count: int | None = None) -> Sample: text = text if text is not None else _repository_header(repo) + "".join( _file_block(path, content, policy, role, part=part, parts=parts) for path, content, policy, role, language, part, parts in entries ) language_by_path = {file.path: file.language for file in info.files} provenance = tuple(SampleFile( path=path, relation="component", content_policy=policy, role=role, language=language_by_path[path], bytes=len(content.encode("utf-8")), part=part, parts=parts, ) for path, content, policy, role, language, part, parts in entries) return Sample( sample_id=_sample_id(repo, "dependency", len(existing), tuple(x[0] for x in entries)), repo_id=repo.repo_id, revision_id=repo.revision_id, kind="dependency", text=text, files=provenance, token_count=token_count if token_count is not None else counter(text), metadata={"component": component_index, "counter": counter.mode}, ) def _target_candidates(repo, info, rendered, config) -> tuple[str, ...]: """Choose stable, broadly distributed source targets without graph ranking.""" roles = {path: value[2] for path, value in rendered.items()} language = {file.path: file.language for file in info.files} candidates = [ path for path in info.topological_order if roles.get(path) == "source" and language.get(path) and rendered[path][0] and rendered[path][1] != "metadata_only" ] if len(candidates) <= config.max_targets_per_repo: return tuple(candidates) ranked = sorted( candidates, key=lambda path: hashlib.sha1( f"{repo.repo_id}\0{repo.revision_id}\0target\0{path}".encode() ).digest(), ) selected = set(ranked[:config.max_targets_per_repo]) return tuple(path for path in info.topological_order if path in selected) def _target_dependencies(info, target: str, max_depth: int) -> tuple[str, ...]: """Return transitive dependencies, preserving dependency-first presentation.""" dependencies: dict[str, set[str]] = {} for edge in info.edges: if edge.status == "resolved" and edge.source != edge.target: dependencies.setdefault(edge.source, set()).add(edge.target) distance = {target: 0} queue = deque([target]) while queue: source = queue.popleft() depth = distance[source] if depth >= max_depth: continue for dependency in sorted(dependencies.get(source, ())): if dependency not in distance: distance[dependency] = depth + 1 queue.append(dependency) position = {path: index for index, path in enumerate(info.topological_order)} return tuple(sorted( (path for path in distance if path != target), key=lambda path: (distance[path], position[path]), )) def _direct_dependencies(info, target: str) -> tuple[str, ...]: position = {path: index for index, path in enumerate(info.topological_order)} return tuple(sorted( { edge.target for edge in info.edges if edge.status == "resolved" and edge.source == target and edge.target != target }, key=position.__getitem__, )) def _target_context_samples(repo, info, rendered, config, counter, existing_samples=()) -> list[Sample]: samples: list[Sample] = [] existing_texts = {sample.text for sample in existing_samples} language = {file.path: file.language for file in info.files} roles = {path: value[2] for path, value in rendered.items()} position = {path: index for index, path in enumerate(info.topological_order)} by_directory: dict[str, list[str]] = {} for path in info.topological_order: parent = path.rsplit("/", 1)[0] if "/" in path else "" by_directory.setdefault(parent, []).append(path) for target in _target_candidates(repo, info, rendered, config): dependency_paths = list(_target_dependencies(info, target, config.max_dependency_depth)) target_content, target_policy, target_role = rendered[target] budget = config.max_tokens - counter(_repository_header(repo)) if budget < 1: continue if config.max_file_tokens is not None: budget = min(budget, config.max_file_tokens) target_parts = _chunks(target, target_content, target_policy, target_role, language.get(target), budget, counter) target_blocks = [ _file_block(target, part, target_policy, target_role, part=index, parts=len(target_parts)) for index, part in enumerate(target_parts, 1) ] for target_index, target_block in enumerate(target_blocks, 1): entries: list[tuple[str, str, str, str, str | None, int, int]] = [] used = counter(target_block) selected: list[str] = [] # Direct dependencies and then nearer transitive dependencies are considered first. for path in dependency_paths: content, policy, role = rendered[path] if policy == "metadata_only": continue parts = _chunks(path, content, policy, role, language.get(path), budget, counter) if len(parts) != 1: continue block = _file_block(path, parts[0], policy, role) if used + counter(block) <= budget: selected.append(path) used += counter(block) dependency_selected = set(selected) # Small local documentation/build context gets the remaining space. target_dir = target.rsplit("/", 1)[0] if "/" in target else "" context_candidates = [ path for path in by_directory.get(target_dir, ()) if path != target and roles.get(path) in {"documentation", "manifest", "build"} ] context_candidates += [ path for path in ("README.md", "README.rst", "pyproject.toml", "package.json", "Cargo.toml") if path in rendered and path != target and path not in context_candidates ] for path in context_candidates: if path in selected: continue content, policy, role = rendered[path] block = _file_block(path, content, policy, role) if counter(block) <= 1024 and used + counter(block) <= budget: selected.append(path) used += counter(block) selected.sort(key=position.__getitem__) for path in selected: content, policy, role = rendered[path] entries.append((path, content, policy, role, language.get(path), 1, 1)) target_part = target_parts[target_index - 1] # A target-only document duplicates the ordinary dependency sample # and adds no repository context, so do not emit it. if not selected: continue entries.append((target, target_part, target_policy, target_role, language.get(target), target_index, len(target_parts))) text = _repository_header(repo) + "".join( _file_block(path, content, policy, role, part=part, parts=parts) for path, content, policy, role, _, part, parts in entries ) if counter(text) > config.max_tokens: continue if text in existing_texts: continue provenance = tuple(SampleFile( path=path, relation=("target" if path == target else "dependency" if path in dependency_selected else "repository_context"), content_policy=policy, role=role, language=language.get(path), bytes=len(content.encode("utf-8")), part=part, parts=parts, ) for path, content, policy, role, _, part, parts in entries) samples.append(Sample( sample_id=_sample_id(repo, "target_context", len(samples), tuple(path for path, *_ in entries)), repo_id=repo.repo_id, revision_id=repo.revision_id, kind="target_context", text=text, files=provenance, token_count=counter(text), metadata={ "target_path": target, "direct_dependency_paths": _direct_dependencies(info, target), "dependency_depth": config.max_dependency_depth, "dependency_paths": tuple(path for path in selected if path in dependency_selected), "repository_context_paths": tuple(path for path in selected if path not in dependency_selected), "counter": counter.mode, }, )) existing_texts.add(text) return samples def _sample_id(repo: Repo, kind: str, index: int, paths: tuple[str, ...]) -> str: value = "\0".join((repo.repo_id, repo.revision_id, kind, str(index), *paths)) return hashlib.sha1(value.encode()).hexdigest()