mirror of
https://github.com/headroomlabs-ai/headroom.git
synced 2026-11-22 13:29:19 +08:00
## Description
This PR removes small helpers that nothing calls. None is in an
`__all__`, a lazy export map or the published docs, and none is imported
by a consumer repo. `align_for_cache` was in an earlier revision of this
PR. Its docstring calls it a stable public API, so it is now kept here
and deprecated in the deprecation PR instead.
Refs #4136
## Type of Change
- [ ] Bug fix (non-breaking change that fixes an issue)
- [ ] New feature (non-breaking change that adds functionality)
- [ ] Breaking change (fix or feature that would cause existing
functionality to change)
- [ ] Documentation update
- [ ] Performance improvement
- [x] Code refactoring (no functional changes)
## Changes Made
- `content_router.route_and_compress`, `code_compressor.compress_code`,
`pipeline.create_pipeline` and `base.split_frozen`: one-off wrappers
with no callers.
- `image.trained_router.get_trained_router`: no callers.
- `content_detector.is_json_array_of_dicts`: test-only. The tests now
assert the `is_dict_array` metadata directly. The Rust
`_core.is_json_array_of_dicts` stays.
- `kompress_compressor._acquire_bounded`: test-only, superseded by the
live acquire path. Its two tests go too.
- `ContentRouter._freeze_pin_chars`: a write-only counter.
- Evidence: `rg -nw '<name>' headroom crates plugins sdk examples
benchmarks scripts e2e docs wiki`, plus the consumer repos, finds only
each definition (and, for the test-only items, the tests named above).
## Testing
- [x] Unit tests pass (`pytest`)
- [x] Linting passes (`ruff check .`)
- [x] Type checking passes (`mypy headroom`)
- [ ] New tests added for new functionality
- [ ] Manual testing performed
### Test Output
```text
$ pytest tests/test_transforms_content_detection.py tests/test_kompress_failsafe.py tests/test_transforms/test_content_router.py tests/test_transforms_content_router.py tests/test_transforms/test_code_compressor.py tests/test_image_compressor.py tests/test_transforms_package.py tests/test_cache_aligner_prefix_stability.py tests/test_cache_aligner_detector_only.py tests/test_pipeline.py tests/test_canonical_pipeline.py tests/test_transforms/test_pipeline_waste_signal_limit.py tests/test_pipeline_outcome_stage.py
405 passed in 19.78s
$ ruff check / format: All checks passed; mypy (4 modules): Success
```
## Real Behavior Proof
- Environment: macOS, Python 3.12, repo `.venv`, this branch's worktree
with the prebuilt `headroom._core`. Temp `HOME`,
`HEADROOM_WORKSPACE_DIR` and `CODEX_HOME`; nothing touched the real
home.
- Exact command / steps: (1) shared smoke harness: a real proxy from
this checkout against a local fake upstream, with one Anthropic and one
OpenAI request carrying a compressible tool result (`smoke.sh
<worktree>`); (2) the content-detector metadata check, `hasattr` checks
for the removed wrappers, and an import of the kept `align_for_cache`.
- Observed result: The proxy serves both requests (200) with the same
savings as main. The detector reports `is_dict_array`, the removed
wrappers are gone, and `align_for_cache` is still importable. Output
below.
- Not tested: Nothing beyond the listed files.
```text
branch: cleanup/transforms-remove-dead-helpers @ 5fa12a0c
health: 200
POST /v1/messages -> HTTP200 smoke-ok
POST /v1/chat/completions -> HTTP200 smoke-ok
stats: requests=2 failed=0 tokens_saved=13574 savings_percent=99.82
proxy.log WARNING/ERROR lines ($SMOKE/ws/logs/proxy-51054.log):
2 headroom.proxy - WARNING - event=proxy_offline_mode air-gap active — every connection Headroom initiates is refused (telemetry, update check, license reporter, model/tokenizer/binary/dataset downloads, remote Kompress, OTLP/Langfuse export, Copilot auth, subscription polling, OpenAI embedders, Headroom Cloud compression). Still allowed on purpose: forwarding your requests to the upstream you configured, operator-configured local endpoints, loopback health probes.
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch found no usable file for chopratejas/kompress-v2-base
4 headroom.transforms.kompress_compressor - WARNING - Kompress: artifact prefetch refused for chopratejas/kompress-v2-base (HEADROOM_OFFLINE is set): HEADROOM_OFFLINE is set: refusing outbound network access for HuggingFace download of chopratejas/kompress-v2-base/onnx/kompress-int8-wo.onnx to huggingface.co. Unset HEADROOM_OFFLINE, or turn off the feature that needs this connection.
(smoke dir: $SMOKE)
```
```text
$ python -c "<detect_content_type on a dict array; hasattr checks for the removed wrappers; import align_for_cache>"
ContentType.JSON_ARRAY {'item_count': 2, 'is_dict_array': True}
[False, False, False]
align_for_cache kept: True
```
## Runtime Rollout Safety
- Rollout-managed feature(s): None.
- Minimum rollout channel: Not applicable; no rollout-managed behaviour
is touched.
- Stable/default behavior changed: No.
- Kill switch / disable path: Not applicable; nothing that runs changes.
- Unsafe override required: No.
- Qualification impact: None.
- Rollback path: Revert this single commit.
## Review Readiness
- [x] I have performed a self-review
- [x] This PR is ready for human review
## Checklist
- [x] My code follows the project's style guidelines
- [x] I have performed a self-review of my code
- [x] I have commented my code, particularly in hard-to-understand areas
- [ ] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [ ] I have added tests that prove my fix is effective or that my
feature works
- [x] New and existing unit tests pass locally with my changes
- [x] I did **not** edit `CHANGELOG.md` — it is generated by
release-please from my Conventional Commit PR title (a CI guard enforces
this)
## Screenshots (if applicable)
Not applicable.
## Additional Notes
Part of maintainer-requested cleanup #4136 (dead code, duplication,
debuggability), split into small PRs for review.
Documentation changes are not in this PR. They are recorded in the
cleanup docs ledger for the single follow-up docs PR.
`ContentRouterConfig.min_section_tokens` (never read, but a public
dataclass field) is left for the maintainer, as asked.
🤖 Generated with [Claude Code](https://claude.com/claude-code)
---------
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
396 lines
16 KiB
Python
396 lines
16 KiB
Python
from __future__ import annotations
|
|
|
|
import json
|
|
|
|
from headroom.transforms.content_detector import (
|
|
ContentType,
|
|
_is_grep_context_line,
|
|
_is_search_result_line,
|
|
_try_detect_code,
|
|
_try_detect_diff,
|
|
_try_detect_html,
|
|
_try_detect_json,
|
|
_try_detect_log,
|
|
_try_detect_search,
|
|
detect_content_type,
|
|
normalize_concatenated_json,
|
|
)
|
|
from headroom.transforms.error_detection import (
|
|
ERROR_INDICATOR_KEYWORDS,
|
|
ERROR_KEYWORDS,
|
|
ERROR_PATTERN,
|
|
IMPORTANCE_KEYWORDS,
|
|
IMPORTANCE_PATTERN,
|
|
PRIORITY_PATTERNS_DIFF,
|
|
PRIORITY_PATTERNS_SEARCH,
|
|
PRIORITY_PATTERNS_TEXT,
|
|
SECURITY_KEYWORDS,
|
|
SECURITY_PATTERN,
|
|
WARNING_PATTERN,
|
|
content_has_error_indicators,
|
|
)
|
|
|
|
|
|
def test_detect_content_type_handles_empty_and_plain_text() -> None:
|
|
empty = detect_content_type(" ")
|
|
assert empty.content_type is ContentType.PLAIN_TEXT
|
|
assert empty.confidence == 0.0
|
|
|
|
plain = detect_content_type("just a normal paragraph with no strong patterns")
|
|
assert plain.content_type is ContentType.PLAIN_TEXT
|
|
assert plain.confidence == 0.5
|
|
|
|
|
|
def test_json_detection_distinguishes_dict_arrays_and_other_lists() -> None:
|
|
dict_result = _try_detect_json('[{"id": 1}, {"id": 2}]')
|
|
assert dict_result is not None
|
|
assert dict_result.content_type is ContentType.JSON_ARRAY
|
|
assert dict_result.confidence == 1.0
|
|
assert dict_result.metadata == {"item_count": 2, "is_dict_array": True}
|
|
|
|
scalar_result = _try_detect_json("[1, 2, 3]")
|
|
assert scalar_result is not None
|
|
assert scalar_result.confidence == 0.8
|
|
assert scalar_result.metadata == {"item_count": 3, "is_dict_array": False}
|
|
|
|
empty_result = _try_detect_json("[]")
|
|
assert empty_result is not None
|
|
assert empty_result.metadata == {"item_count": 0, "is_dict_array": False}
|
|
|
|
# JSON OBJECTS are recognized too (config/data files are ``{…}``, not arrays).
|
|
object_result = _try_detect_json('{"id": 1}')
|
|
assert object_result is not None
|
|
assert object_result.content_type is ContentType.JSON_ARRAY
|
|
assert object_result.metadata == {"is_dict_array": False, "is_object": True}
|
|
|
|
assert _try_detect_json("[not valid json") is None
|
|
|
|
|
|
def test_space_separated_json_objects_detected_as_array() -> None:
|
|
# Typical web_search output: back-to-back JSON objects, no array brackets.
|
|
content = " ".join(
|
|
json.dumps({"title": f"Result {i}", "url": f"http://example.com/{i}"}) for i in range(3)
|
|
)
|
|
result = _try_detect_json(content)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.JSON_ARRAY
|
|
assert result.confidence == 1.0
|
|
assert result.metadata == {"item_count": 3, "is_dict_array": True, "concatenated": True}
|
|
|
|
# Reaches the same verdict through the top-level detector (not PLAIN_TEXT).
|
|
top_level = detect_content_type(content)
|
|
assert top_level.content_type is ContentType.JSON_ARRAY
|
|
assert top_level.metadata.get("is_dict_array") is True
|
|
|
|
# Newline separation is just as common and must also be recognized.
|
|
newline_sep = "\n".join(json.dumps({"id": i, "snippet": "x"}) for i in range(2))
|
|
assert _try_detect_json(newline_sep).content_type is ContentType.JSON_ARRAY
|
|
|
|
|
|
def test_json_detection_is_liberal_but_bulk_gated() -> None:
|
|
# Liberal (parse-based): a lone JSON object IS structured data worth routing —
|
|
# config/data files are ``{...}`` (chosen over the earlier conservative stance
|
|
# when this PR merged with the concatenated-JSON detector, #1742).
|
|
assert _try_detect_json('{"id": 1}').content_type is ContentType.JSON_ARRAY
|
|
# But a JSON fragment that is only a minority of the content (prose or a loose
|
|
# scalar around it) is NOT claimed — the decoded value must be the bulk.
|
|
assert _try_detect_json('{"id": 1} then some prose {"id": 2}') is None
|
|
assert _try_detect_json('{"id": 1} "loose string"') is None
|
|
|
|
|
|
def test_normalize_concatenated_json_roundtrips_to_array() -> None:
|
|
content = '{"a": 1} {"b": 2}'
|
|
normalized = normalize_concatenated_json(content)
|
|
assert normalized is not None
|
|
assert json.loads(normalized) == [{"a": 1}, {"b": 2}]
|
|
|
|
# Already-valid arrays and single objects are left for the caller as-is.
|
|
assert normalize_concatenated_json('[{"a": 1}]') is None
|
|
assert normalize_concatenated_json('{"a": 1}') is None
|
|
|
|
|
|
def test_diff_detection_tracks_headers_and_changes() -> None:
|
|
diff = "\n".join(
|
|
[
|
|
"diff --git a/app.py b/app.py",
|
|
"--- a/app.py",
|
|
"@@ -1,2 +1,2 @@",
|
|
"-old line",
|
|
"+new line",
|
|
]
|
|
)
|
|
result = _try_detect_diff(diff)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.GIT_DIFF
|
|
assert result.metadata["header_matches"] == 3
|
|
assert result.metadata["change_lines"] == 2
|
|
assert result.confidence == 1.0
|
|
assert detect_content_type(diff).content_type is ContentType.GIT_DIFF
|
|
|
|
assert _try_detect_diff("+not enough by itself") is None
|
|
|
|
|
|
def test_html_detection_requires_real_structure() -> None:
|
|
html = """
|
|
<!DOCTYPE html>
|
|
<html>
|
|
<head><meta charset="utf-8"></head>
|
|
<body><main><section><div>Hello</div><nav>Links</nav></section></main></body>
|
|
</html>
|
|
"""
|
|
result = _try_detect_html(html)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.HTML
|
|
assert result.metadata["has_doctype"] is True
|
|
assert result.metadata["has_html_tag"] is True
|
|
assert result.metadata["structural_tags"] >= 3
|
|
assert detect_content_type(html).content_type is ContentType.HTML
|
|
|
|
assert _try_detect_html("<div>only one tag</div>") is None
|
|
assert _try_detect_html("<html><title>too sparse</title></html>") is None
|
|
|
|
|
|
def test_search_detection_uses_match_ratio() -> None:
|
|
search_output = "\n".join(
|
|
[
|
|
"src/app.py:10:def main():",
|
|
"src/app.py:20:print('hello')",
|
|
"README.md:5:usage docs",
|
|
"plain text footer",
|
|
]
|
|
)
|
|
result = _try_detect_search(search_output)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.SEARCH_RESULTS
|
|
assert result.metadata == {"matching_lines": 3, "total_lines": 4}
|
|
assert result.confidence == 0.85
|
|
assert detect_content_type(search_output).content_type is ContentType.SEARCH_RESULTS
|
|
|
|
assert _try_detect_search("one:1:match\nplain\nplain\nplain") is None
|
|
assert _try_detect_search("\n\n") is None
|
|
|
|
|
|
def test_search_detection_rejects_datetime_prefixed_user_message() -> None:
|
|
"""Regression: wrap-copilot ate one-line interactive prompts (2026-08-23).
|
|
|
|
Copilot CLI prepends ``<current_datetime>…</current_datetime>`` to every
|
|
interactive user turn. The ISO-8601 ``T09:57:59`` matched the grep
|
|
``file:line:`` pattern, so a datetime + one-line prompt classified as
|
|
SEARCH_RESULTS (1 match / 2 lines = 50% ≥ 30%) and the SearchCompressor
|
|
deleted the prompt line — the model received only the timestamp.
|
|
"""
|
|
incident = (
|
|
"<current_datetime>2026-08-23T09:57:59.792+02:00</current_datetime>\n"
|
|
"\n"
|
|
"Please update the PR desc and check .overlay/ for hints."
|
|
)
|
|
assert _try_detect_search(incident) is None
|
|
assert detect_content_type(incident).content_type is not ContentType.SEARCH_RESULTS
|
|
|
|
|
|
def test_search_detection_requires_two_matching_lines() -> None:
|
|
"""A single coincidental ``word:digits:`` line must not classify prose."""
|
|
assert _try_detect_search("src/foo.py:12:def foo():") is None
|
|
assert (
|
|
_try_detect_search(
|
|
"Meeting at 09:30:00 tomorrow.\nBring the reports.\nDo not forget coffee."
|
|
)
|
|
is None
|
|
)
|
|
# Two genuine grep lines still classify.
|
|
two = "src/foo.py:12:def foo():\nsrc/bar.py:34: foo()"
|
|
result = _try_detect_search(two)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.SEARCH_RESULTS
|
|
|
|
|
|
def test_search_detection_rejects_tag_like_and_key_value_prefixes() -> None:
|
|
"""Markup / key=value lines are not file paths even with ``:\\d+:`` inside."""
|
|
assert (
|
|
_try_detect_search('<log time="10:00:00">started</log>\n<log time="10:00:01">stopped</log>')
|
|
is None
|
|
)
|
|
assert _try_detect_search("timeout=30:12:retried\ntimeout=31:12:retried") is None
|
|
|
|
|
|
def test_search_detection_classifies_grep_context_lines() -> None:
|
|
"""Regression (#3580): ``grep -A/-B/-C`` context lines are search output.
|
|
|
|
GNU grep separates context lines with ``-`` (``path-NN-content``) instead
|
|
of the ``:`` match lines use. The dash alone flipped detection to
|
|
PLAIN_TEXT, routing source code into the word-dropping Kompress prose
|
|
compressor. Context lines must classify as SEARCH_RESULTS, exactly like
|
|
the colon-separated match lines already do.
|
|
"""
|
|
code = [
|
|
'env = payload.get("env")',
|
|
"env_map = dict(env) if isinstance(env, dict) else {}",
|
|
"previous = {name: env_map.get(name) for name in values}",
|
|
'payload["env"] = env_map',
|
|
'path.write_text(json.dumps(payload, indent=2), encoding="utf-8")',
|
|
]
|
|
path = "./headroom/providers/claude/install.py"
|
|
|
|
def build(sep: str) -> str:
|
|
return "\n".join(
|
|
f"{path}:{40 + i}{sep}{line}" for _ in range(14) for i, line in enumerate(code)
|
|
)
|
|
|
|
for sep in (":", "-"):
|
|
result = _try_detect_search(build(sep))
|
|
assert result is not None, f"separator {sep!r} not detected as search"
|
|
assert result.content_type is ContentType.SEARCH_RESULTS
|
|
assert result.metadata == {"matching_lines": 70, "total_lines": 70}
|
|
assert detect_content_type(build(sep)).content_type is ContentType.SEARCH_RESULTS
|
|
|
|
|
|
def test_grep_context_line_predicate_guards() -> None:
|
|
"""The ``path-NN-content`` shape must not claim dates, prose, or markup."""
|
|
# Genuine context lines, including dashed file names and ripgrep output.
|
|
assert _is_grep_context_line("src/main.py-40-some context before")
|
|
assert _is_grep_context_line("src/my-file.py-12-x = 1")
|
|
assert _is_grep_context_line("./headroom/providers/claude/install.py-40- x = 1")
|
|
# Group separators and single dashes are never matches.
|
|
assert not _is_grep_context_line("--")
|
|
assert not _is_grep_context_line("-")
|
|
# Dates and dashed prose have no path-shaped prefix (no ``/`` or ``.``).
|
|
assert not _is_grep_context_line("2026-09-14")
|
|
assert not _is_grep_context_line("2026-09-14-release-notes-here")
|
|
assert not _is_grep_context_line("version-2-release")
|
|
# Markup / key=value prefixes are excluded, mirroring the colon branch.
|
|
assert not _is_grep_context_line('<log time="10-00-00">started</log>')
|
|
assert not _is_grep_context_line("timeout=30-12-retried")
|
|
|
|
|
|
def test_grep_colon_dash_shape_routes_like_context() -> None:
|
|
"""``path:NN-content`` (the reported repro shape) is search output too."""
|
|
assert _is_search_result_line("src/main.py:40- context before")
|
|
assert _is_search_result_line("./headroom/x.py:40-env = payload.get(1)")
|
|
# Same prefix exclusions as the colon branch.
|
|
assert not _is_search_result_line('<log time="10:00-00">started</log>')
|
|
assert not _is_search_result_line("timeout=30:12-retried")
|
|
|
|
|
|
def test_search_detection_mixed_match_and_context_block() -> None:
|
|
"""A ``grep -C`` block mixing ``:`` matches, ``-`` context, and ``--``."""
|
|
block = "\n".join(
|
|
[
|
|
"src/main.py-40- context before",
|
|
"src/main.py:42:def process_data(items):",
|
|
"src/main.py-43- context after",
|
|
"--",
|
|
"src/other.py-10- more context",
|
|
"src/other.py:12: return True",
|
|
"src/other.py-13- trailing context",
|
|
]
|
|
)
|
|
result = _try_detect_search(block)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.SEARCH_RESULTS
|
|
# Six grep-shaped lines out of seven (``--`` is a separator, not a match).
|
|
assert result.metadata == {"matching_lines": 6, "total_lines": 7}
|
|
assert detect_content_type(block).content_type is ContentType.SEARCH_RESULTS
|
|
|
|
|
|
def test_search_detection_single_context_line_stays_unclaimed() -> None:
|
|
"""One coincidental ``path-NN`` line must not classify prose (floor of 2)."""
|
|
assert _try_detect_search("src/foo.py-12- foo()") is None
|
|
|
|
|
|
def test_log_detection_prefers_build_output_patterns() -> None:
|
|
log_output = "\n".join(
|
|
[
|
|
"2025-01-01 Starting run",
|
|
"ERROR failed to compile",
|
|
"WARNING retrying build",
|
|
"PASSED unit test",
|
|
"Traceback (most recent call last)",
|
|
"plain footer",
|
|
]
|
|
)
|
|
result = _try_detect_log(log_output)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.BUILD_OUTPUT
|
|
assert result.metadata == {"pattern_matches": 5, "error_matches": 2, "total_lines": 6}
|
|
assert result.confidence == 0.8166666666666667
|
|
assert detect_content_type(log_output).content_type is ContentType.BUILD_OUTPUT
|
|
|
|
assert _try_detect_log("plain\ntext\nonly") is None
|
|
assert _try_detect_log("\n\n") is None
|
|
assert _try_detect_log("\n".join(["ERROR one", *["plain"] * 15])) is None
|
|
|
|
|
|
def test_code_detection_identifies_language_and_thresholds() -> None:
|
|
python_code = "\n".join(
|
|
[
|
|
"import os",
|
|
"from pathlib import Path",
|
|
"",
|
|
"@cached",
|
|
"class App:",
|
|
" pass",
|
|
"def main():",
|
|
' """Run."""',
|
|
]
|
|
)
|
|
result = _try_detect_code(python_code)
|
|
assert result is not None
|
|
assert result.content_type is ContentType.SOURCE_CODE
|
|
assert result.metadata == {"language": "python", "pattern_matches": 6}
|
|
assert result.confidence == 0.8628571428571429
|
|
assert detect_content_type(python_code).content_type is ContentType.SOURCE_CODE
|
|
|
|
assert _try_detect_code("function maybe() {}\nplain text") is None
|
|
assert _try_detect_code("import os\ndef main():") is None
|
|
assert _try_detect_code("\n\n") is None
|
|
|
|
|
|
def test_detect_content_type_respects_priority_order() -> None:
|
|
diff_like_search = "\n".join(
|
|
[
|
|
"diff --git a/src/app.py b/src/app.py",
|
|
"@@ -1,1 +1,1 @@",
|
|
"+src/app.py:10:def still_diff_first()",
|
|
]
|
|
)
|
|
assert detect_content_type(diff_like_search).content_type is ContentType.GIT_DIFF
|
|
|
|
|
|
def test_error_detection_keywords_patterns_and_indicator_helper() -> None:
|
|
assert {"error", "failed", "critical"} <= ERROR_KEYWORDS
|
|
# fixed_in_3e1: ERROR_KEYWORDS canonically had timeout/abort/denied/rejected
|
|
# but the regex omitted them; the Rust port + Python shim now align.
|
|
assert {"timeout", "abort", "denied", "rejected"} <= ERROR_KEYWORDS
|
|
assert {"warning", "todo", "fix"} <= IMPORTANCE_KEYWORDS
|
|
# fixed_in_3e1: 'token' was dropped from SECURITY_KEYWORDS because it
|
|
# false-positived on every LLM-token reference (input_tokens, etc.) in
|
|
# an LLM-proxy product. 'auth' carries the real security signal.
|
|
assert {"security", "password", "auth", "secret"} <= SECURITY_KEYWORDS
|
|
assert "token" not in SECURITY_KEYWORDS
|
|
assert ERROR_INDICATOR_KEYWORDS[0] == "error"
|
|
|
|
assert ERROR_PATTERN.search("Fatal error occurred")
|
|
# fixed_in_3e1: timeout now matched by ERROR_PATTERN regex.
|
|
assert ERROR_PATTERN.search("Connection timeout occurred")
|
|
assert WARNING_PATTERN.search("warning: be careful")
|
|
assert IMPORTANCE_PATTERN.search("TODO fix this hack")
|
|
# fixed_in_3e1: pre-3e1 this matched via 'token'; now matches via 'auth'.
|
|
assert SECURITY_PATTERN.search("rotate the auth header")
|
|
# fixed_in_3e1: lone 'token' references no longer trigger security routing.
|
|
assert SECURITY_PATTERN.search("input_tokens=512 output_tokens=128") is None
|
|
|
|
assert PRIORITY_PATTERNS_SEARCH[:3] == [ERROR_PATTERN, WARNING_PATTERN, IMPORTANCE_PATTERN]
|
|
assert PRIORITY_PATTERNS_DIFF == [ERROR_PATTERN, IMPORTANCE_PATTERN, SECURITY_PATTERN]
|
|
assert PRIORITY_PATTERNS_TEXT[0] is ERROR_PATTERN
|
|
assert PRIORITY_PATTERNS_TEXT[1] is IMPORTANCE_PATTERN
|
|
# The Rust-supplied markdown_prefixes order is `# `, `## `, `### `, `#### `,
|
|
# `**`, `> ` (see KeywordRegistry::default_set). Index 2 is `# ` not `## `,
|
|
# so anchor each assertion on the prefix it actually owns.
|
|
assert PRIORITY_PATTERNS_TEXT[2].match("# Top-level heading")
|
|
assert PRIORITY_PATTERNS_TEXT[3].match("## Subheading")
|
|
assert PRIORITY_PATTERNS_TEXT[6].match("**Bold")
|
|
assert PRIORITY_PATTERNS_TEXT[7].match("> quote")
|
|
|
|
assert content_has_error_indicators("TRACEBACK: Fatal crash in worker") is True
|
|
assert content_has_error_indicators("Everything completed successfully") is False
|