File size: 11,059 Bytes
f764cdf 917c16d f764cdf 02ebb32 f764cdf 02ebb32 f764cdf 02ebb32 f764cdf 02ebb32 917c16d f764cdf 02ebb32 f764cdf 02ebb32 f764cdf 02ebb32 f764cdf 02ebb32 f764cdf 02ebb32 f764cdf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 | import json
from stackbuild import (
BuildConfig,
Repo,
RepoFile,
SPECIAL_TOKENS,
build_samples,
dependency_components,
scan,
write_jsonl,
)
from stackbuild.builder import _Counter, _chunks, _file_block, _repository_header
class CharacterTokenizer:
def encode(self, text, add_special_tokens=False):
return list(text)
class TiktokenLikeTokenizer:
def encode(self, text, *, disallowed_special):
assert disallowed_special == ()
return list(text.encode())
class BoundedCharacterTokenizer:
def __init__(self, maximum_input):
self.maximum_input = maximum_input
self.largest_input = 0
def encode(self, text, add_special_tokens=False):
self.largest_input = max(self.largest_input, len(text))
if len(text) > self.maximum_input:
raise AssertionError(f"unbounded tokenizer input: {len(text)}")
return range(len(text))
def demo_repo():
return Repo("owner/demo", "rev1", (
RepoFile("README.md", "# Demo\n", "Markdown"),
RepoFile("model.py", "VALUE = 1\n", "Python"),
RepoFile("service.py", "import model\ndef get():\n return model.VALUE\n", "Python"),
RepoFile("main.py", "import service\nprint(service.get())\n", "Python"),
))
def test_dependency_components_are_complete_and_dependency_ordered():
info = scan(demo_repo(), use_treesitter=False)
components = dependency_components(info)
assert {frozenset(component) for component in components} == {
frozenset({"model.py", "service.py", "main.py"}),
frozenset({"README.md"}),
}
code = next(component for component in components if "main.py" in component)
assert code.index("model.py") < code.index("service.py") < code.index("main.py")
def test_build_emits_only_dependency_samples_in_dependency_order():
samples = build_samples(
demo_repo(), config=BuildConfig(max_tokens=1000), tokenizer=CharacterTokenizer(),
)
assert samples
assert {sample.kind for sample in samples} == {"dependency"}
assert all(sample.token_count == len(sample.text) <= 1000 for sample in samples)
assert {file.path for sample in samples for file in sample.files} == {
"README.md", "model.py", "service.py", "main.py",
}
code = next(sample for sample in samples if any(file.path == "main.py" for file in sample.files))
paths = [file.path for file in code.files]
assert paths.index("model.py") < paths.index("service.py") < paths.index("main.py")
assert code.text.index("model.py") < code.text.index("service.py") < code.text.index("main.py")
def test_large_file_is_split_at_budget():
content = "".join(f"line_{index:03d} = {index}\n" for index in range(100))
repo = Repo("large", "r1", (RepoFile("large.py", content, "Python"),))
samples = build_samples(
repo, config=BuildConfig(max_tokens=180), tokenizer=CharacterTokenizer(),
)
assert len(samples) > 1
assert all(sample.token_count <= 180 for sample in samples)
files = [file for sample in samples for file in sample.files]
assert [file.part for file in files] == list(range(1, files[0].parts + 1))
def test_huge_file_never_sends_the_whole_file_to_tokenizer():
tokenizer = BoundedCharacterTokenizer(280_000)
content = ("x" * 1_000_000) + "\n"
samples = build_samples(
Repo("huge", "r1", (RepoFile("huge.txt", content, None),)),
config=BuildConfig(max_tokens=8192), tokenizer=tokenizer,
)
assert len(samples) > 100
assert tokenizer.largest_input <= 280_000
assert all(sample.token_count <= 8192 for sample in samples)
assert sum(file.bytes for sample in samples for file in sample.files) == len(content)
def _reference_chunks(path, content, policy, role, budget, counter):
max_candidate_chars = 262_144
if len(content) <= max_candidate_chars and counter(
_file_block(path, content, policy, role)
) <= budget:
return (content,)
def split_block(value):
return _file_block(path, value, policy, role, part=999_999, parts=999_999)
units = []
for line in content.splitlines(keepends=True):
units.extend(line[index:index + 16_384] for index in range(0, len(line), 16_384))
chunks, current = [], ""
for unit in units:
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
low, high, chars = 1, len(unit), 0
while low <= high:
middle = (low + high) // 2
if counter(split_block(unit[:middle])) <= budget:
chars, low = middle, middle + 1
else:
high = middle - 1
assert chars
chunks.append(unit[:chars])
unit = unit[chars:]
if current:
chunks.append(current)
return tuple(chunks)
def test_chunk_binary_search_preserves_exact_greedy_boundaries():
content = "".join(f"row_{index:04d} = {index}\n" for index in range(2_000))
counter = _Counter(CharacterTokenizer())
budget = 900 - counter(_repository_header(Repo("repo", "rev", ())))
expected = _reference_chunks("large.py", content, "full", "source", budget, counter)
actual = _chunks("large.py", content, "full", "source", "Python", budget, counter)
assert actual == expected
def test_notebook_is_structured_and_binary_is_metadata_only():
notebook = json.dumps({
"metadata": {"kernelspec": {"language": "python"}},
"cells": [
{"cell_type": "markdown", "source": ["Explain x"]},
{"cell_type": "code", "source": ["x = 1\n"],
"outputs": [{"output_type": "stream", "text": ["1\n"]}]},
],
})
repo = Repo("mixed", "r1", (
RepoFile("analysis.ipynb", notebook, "Jupyter Notebook"),
RepoFile("image.png", b"\x89PNG\x00payload", None),
))
samples = build_samples(repo, config=BuildConfig(max_tokens=1_000))
text = "".join(sample.text for sample in samples)
assert "# Cell: Markdown\nExplain x" in text
assert "# Cell: Code\nx = 1" in text
assert "# Cell: Output\n1" in text
assert "<｜begin▁of▁file▁name｜>image.png<｜end▁of▁file▁name｜>" in text
binary = next(file for sample in samples for file in sample.files if file.path == "image.png")
assert binary.content_policy == "metadata_only"
def test_isolated_files_are_packed_instead_of_one_sample_each():
repo = Repo("isolated", "r1", tuple(
RepoFile(f"docs/{index}.md", f"document {index}\n", "Markdown")
for index in range(20)
))
samples = build_samples(
repo, config=BuildConfig(max_tokens=400), tokenizer=CharacterTokenizer(),
)
assert len(samples) < 20
assert {file.path for sample in samples for file in sample.files} == {
f"docs/{index}.md" for index in range(20)
}
def test_tiktoken_style_encoder_is_supported():
samples = build_samples(
demo_repo(), config=BuildConfig(max_tokens=400), tokenizer=TiktokenLikeTokenizer(),
)
assert samples
assert all(sample.token_count <= 400 for sample in samples)
def test_one_shot_repo_file_iterable_is_supported():
files = (file for file in (
RepoFile("base.py", "VALUE = 1\n", "Python"),
RepoFile("main.py", "import base\nprint(base.VALUE)\n", "Python"),
))
samples = build_samples(
Repo("generator", "r1", files), config=BuildConfig(max_tokens=400),
tokenizer=CharacterTokenizer(),
)
assert {file.path for sample in samples for file in sample.files} == {"base.py", "main.py"}
def test_samples_round_trip_as_jsonl(tmp_path):
samples = build_samples(
demo_repo(), config=BuildConfig(max_tokens=400), tokenizer=CharacterTokenizer(),
)
target = tmp_path / "samples.jsonl"
write_jsonl(samples, target)
rows = [json.loads(line) for line in target.read_text().splitlines()]
assert [row["sample_id"] for row in rows] == [sample.sample_id for sample in samples]
assert rows[0]["files"][0]["role"]
def test_samples_use_only_repository_and_file_special_tokens():
repo = Repo("comments", "rev", (
RepoFile("a.py", "VALUE = 1\n", "Python"),
RepoFile("b.ts", "export const value = 1;\n", "TypeScript"),
RepoFile("README.md", "Documentation\n", "Markdown"),
))
text = "".join(sample.text for sample in build_samples(
repo, config=BuildConfig(max_tokens=1_000), tokenizer=CharacterTokenizer(),
))
assert len(SPECIAL_TOKENS) == 6
assert "<｜begin▁of▁repo▁name｜>comments<｜end▁of▁repo▁name｜>\n" in text
assert "<｜begin▁of▁file▁name｜>a.py<｜end▁of▁file▁name｜>" in text
assert "<｜begin▁of▁file▁name｜>b.ts<｜end▁of▁file▁name｜>" in text
assert "<｜begin▁of▁file▁name｜>README.md<｜end▁of▁file▁name｜>" in text
assert "rev" not in text
assert "<|endoftext|>" not in text
assert "<|fim_" not in text
custom_tokens = {
"<｜" + part.split("｜>", 1)[0] + "｜>"
for part in text.split("<｜")[1:]
}
assert custom_tokens == set(SPECIAL_TOKENS)
samples = build_samples(
repo, config=BuildConfig(max_tokens=1_000), tokenizer=CharacterTokenizer(),
)
assert all(sample.text.startswith("<｜begin▁of▁repo▁name｜>comments<｜end▁of▁repo▁name｜>\n") for sample in samples)
assert all(
sample.text.count("<｜begin▁of▁file▁name｜>") == len(sample.files)
for sample in samples
)
def test_target_context_samples_select_targets_and_put_dependencies_first():
samples = build_samples(
demo_repo(),
config=BuildConfig(
max_tokens=1_000, target_context=True, max_targets_per_repo=8,
max_dependency_depth=3,
),
tokenizer=CharacterTokenizer(),
)
contexts = [sample for sample in samples if sample.kind == "target_context"]
assert contexts
main = next(sample for sample in contexts if sample.metadata["target_path"] == "main.py")
paths = [file.path for file in main.files]
assert paths[-1] == "main.py"
assert paths.index("model.py") < paths.index("service.py") < paths.index("main.py")
assert main.files[-1].relation == "target"
assert all(sample.token_count <= 1_000 for sample in contexts)
def test_target_context_skips_target_only_duplicates():
repo = Repo("single", "r1", (
RepoFile("src/only.py", "VALUE = 1\n", "Python"),
))
samples = build_samples(
repo,
config=BuildConfig(target_context=True, max_targets_per_repo=8),
tokenizer=CharacterTokenizer(),
)
assert len(samples) == 1
assert samples[0].kind == "dependency"
|