xtremeparse 0.1.0__tar.gz

xtremeparse-0.1.0/.gitignore

@@ -0,0 +1,15 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+
+# Workspace Local
+.env
+.claude
+.DS_Store

xtremeparse-0.1.0/.python-version

@@ -0,0 +1 @@
+3.13

xtremeparse-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Flow Jiang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

xtremeparse-0.1.0/PKG-INFO

@@ -0,0 +1,119 @@
+Metadata-Version: 2.5
+Name: xtremeparse
+Version: 0.1.0
+Summary: XtremeParse: extreme-concurrency structured extraction — chunk, route, fan out, self-correct
+Project-URL: Homepage, https://github.com/flowjzh/xtremeparse
+Project-URL: Repository, https://github.com/flowjzh/xtremeparse.git
+Project-URL: Issues, https://github.com/flowjzh/xtremeparse/issues
+Author-email: Flow Jiang <flowjzh@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: concurrency,extraction,json-schema,llm,parsing,structured-data
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: xtremeflow>=0.1.0
+Provides-Extra: evals
+Requires-Dist: pydantic-evals; extra == 'evals'
+Description-Content-Type: text/markdown
+
+# XtremeParse
+
+> **"Feed it text and a schema. Get structure back — fast."**
+
+XtremeParse is an extreme-concurrency structured-extraction engine for LLM
+pipelines. Given plain text and a JSON Schema, it:
+
+1. **Chunks** the text deterministically (markdown structure → sentence
+   punctuation → character windows — single-line inputs included).
+2. **Routes** chunks to extraction units via one light agent call that
+   outputs only an index map (minimal output tokens, maximal speed) and
+   itemizes repeated content for fan-out.
+3. **Fans out** one specialist per unit — per item for long repeated
+   sections, whole-array for short ones — under xtremeflow's scheduler.
+4. **Self-corrects**: validates the merged result with your validator,
+   routes issues back to the failing specialists, and re-runs only them
+   with the errors appended to their conversation history.
+
+The full-text prefix is shared across all calls to maximize provider-side
+KV-cache hits; the router runs first and warms the cache for the fleet
+behind it.
+
+## Quick start
+
+```python
+from xtremeparse import Extractor
+
+class MyRunner:  # adapt your agent framework (PydanticAI, ...)
+    async def run(self, *, instructions, result_schema, content,
+                  scope=None, tools=None, history=None, feedback=None): ...
+
+extractor = Extractor(MyRunner())
+
+result = await extractor.extract(text, json_schema, validator)
+result.data    # best-effort schema-shaped dict
+result.issues  # unresolved error-level issues (lenient, never raises)
+result.trace   # chunks, router index map, specialist calls, correction rounds
+```
+
+## Neutral by design
+
+The library has zero vendor dependencies beyond `xtremeflow`. It never
+imports your schema tool, your agent framework, or your validator:
+
+- **Structure contract** — JSON Schema dict in, schema-conforming dict out.
+- **Validation contract** — you inject a `validator` callable returning
+  error-level `Issue` objects (anything with `path`/`code`/`message`/
+  `expected`/`got` conforms, zero adapter code).
+- **Agent contract** — you adapt an `AgentRunner` to your framework
+  (PydanticAI, or whatever comes next).
+
+Extraction never raises on imperfect data: `ExtractionResult.data` is the
+best effort and `.issues` tells the truth. Strictness is your policy.
+
+Tuning knobs (constructor): `unit_strategy={'path': 'per-item' | 'whole'}`
+prior knowledge for array units, `output_budgets={'path': n | [n, ...]}`
+to override the router's own `@<n>` arrangements, `max_rounds` for the
+correction budget, `max_chars` for chunk size, `max_concurrency` for the
+scheduler. The three pipeline prompts are replaceable too —
+`router_instructions` / `recount_instructions` / `specialist_instructions`
+(see [docs/prompting.md](docs/prompting.md); the routing DSL they elicit
+is a public contract, [docs/dsl.md](docs/dsl.md)).
+
+## Trace contract
+
+`result.trace` is eval-facing API — stable keys, populated by the
+pipeline stages:
+
+| key | shape |
+|---|---|
+| `chunks` | the chunk list the router saw |
+| `router` | `{'counts': {path: n}, 'assignments': [{'unit', 'item', 'chunks'}], 'budgets': {path: n \| [n, ...]}}` |
+| `groups` | one per specialist call: `{'unit', 'kind', 'item', 'strategy', 'chunk_ids', 'budget', 'batch'}` |
+| `corrections` | one per re-run: `{'unit_path', 'item', 'issue_paths'}` |
+| `prompts` | per prompt slot: `'default'` or `#<sha1-8>` of a host override |
+
+Eval support: `xtremeparse.evalkit` (zero-dep) reads budgets and router
+invariants back out of a trace; `xtremeparse.judging` runs one rubric
+call through the same `AgentRunner` neutrality (bring your own judge —
+a model other than the extraction fleet's and temperature 0 both read
+better, measured); `pip install xtremeparse[evals]` adds pydantic-evals
+adapters (`RouterOverlap`, `BudgetFit`, `RubricJudge`) over those
+mechanisms for hosts building regression suites.
+
+## Status
+
+Pipeline complete (chunk → route → fan out → merge → correct), 160+
+deterministic tests, zero LLM required for the suite. See
+`apps/cvspectra/docs/` in the cohirerx monorepo for the governing design
+and implementation plan.

xtremeparse-0.1.0/README.md

@@ -0,0 +1,90 @@
+# XtremeParse
+
+> **"Feed it text and a schema. Get structure back — fast."**
+
+XtremeParse is an extreme-concurrency structured-extraction engine for LLM
+pipelines. Given plain text and a JSON Schema, it:
+
+1. **Chunks** the text deterministically (markdown structure → sentence
+   punctuation → character windows — single-line inputs included).
+2. **Routes** chunks to extraction units via one light agent call that
+   outputs only an index map (minimal output tokens, maximal speed) and
+   itemizes repeated content for fan-out.
+3. **Fans out** one specialist per unit — per item for long repeated
+   sections, whole-array for short ones — under xtremeflow's scheduler.
+4. **Self-corrects**: validates the merged result with your validator,
+   routes issues back to the failing specialists, and re-runs only them
+   with the errors appended to their conversation history.
+
+The full-text prefix is shared across all calls to maximize provider-side
+KV-cache hits; the router runs first and warms the cache for the fleet
+behind it.
+
+## Quick start
+
+```python
+from xtremeparse import Extractor
+
+class MyRunner:  # adapt your agent framework (PydanticAI, ...)
+    async def run(self, *, instructions, result_schema, content,
+                  scope=None, tools=None, history=None, feedback=None): ...
+
+extractor = Extractor(MyRunner())
+
+result = await extractor.extract(text, json_schema, validator)
+result.data    # best-effort schema-shaped dict
+result.issues  # unresolved error-level issues (lenient, never raises)
+result.trace   # chunks, router index map, specialist calls, correction rounds
+```
+
+## Neutral by design
+
+The library has zero vendor dependencies beyond `xtremeflow`. It never
+imports your schema tool, your agent framework, or your validator:
+
+- **Structure contract** — JSON Schema dict in, schema-conforming dict out.
+- **Validation contract** — you inject a `validator` callable returning
+  error-level `Issue` objects (anything with `path`/`code`/`message`/
+  `expected`/`got` conforms, zero adapter code).
+- **Agent contract** — you adapt an `AgentRunner` to your framework
+  (PydanticAI, or whatever comes next).
+
+Extraction never raises on imperfect data: `ExtractionResult.data` is the
+best effort and `.issues` tells the truth. Strictness is your policy.
+
+Tuning knobs (constructor): `unit_strategy={'path': 'per-item' | 'whole'}`
+prior knowledge for array units, `output_budgets={'path': n | [n, ...]}`
+to override the router's own `@<n>` arrangements, `max_rounds` for the
+correction budget, `max_chars` for chunk size, `max_concurrency` for the
+scheduler. The three pipeline prompts are replaceable too —
+`router_instructions` / `recount_instructions` / `specialist_instructions`
+(see [docs/prompting.md](docs/prompting.md); the routing DSL they elicit
+is a public contract, [docs/dsl.md](docs/dsl.md)).
+
+## Trace contract
+
+`result.trace` is eval-facing API — stable keys, populated by the
+pipeline stages:
+
+| key | shape |
+|---|---|
+| `chunks` | the chunk list the router saw |
+| `router` | `{'counts': {path: n}, 'assignments': [{'unit', 'item', 'chunks'}], 'budgets': {path: n \| [n, ...]}}` |
+| `groups` | one per specialist call: `{'unit', 'kind', 'item', 'strategy', 'chunk_ids', 'budget', 'batch'}` |
+| `corrections` | one per re-run: `{'unit_path', 'item', 'issue_paths'}` |
+| `prompts` | per prompt slot: `'default'` or `#<sha1-8>` of a host override |
+
+Eval support: `xtremeparse.evalkit` (zero-dep) reads budgets and router
+invariants back out of a trace; `xtremeparse.judging` runs one rubric
+call through the same `AgentRunner` neutrality (bring your own judge —
+a model other than the extraction fleet's and temperature 0 both read
+better, measured); `pip install xtremeparse[evals]` adds pydantic-evals
+adapters (`RouterOverlap`, `BudgetFit`, `RubricJudge`) over those
+mechanisms for hosts building regression suites.
+
+## Status
+
+Pipeline complete (chunk → route → fan out → merge → correct), 160+
+deterministic tests, zero LLM required for the suite. See
+`apps/cvspectra/docs/` in the cohirerx monorepo for the governing design
+and implementation plan.

xtremeparse-0.1.0/docs/dsl.md

@@ -0,0 +1,101 @@
+# The routing DSL
+
+The router's entire output is a segment map plus count declarations in a
+compact line DSL. The library parses it, validates it, and repairs it
+with precise feedback; a host that overrides the router prompt
+([prompting.md](prompting.md)) must elicit exactly this language — the
+grammar below is a stable public contract. Breaking it is a breaking
+change.
+
+## Shape
+
+Output is map lines first, then exactly one declaration line per
+repeating (array) unit.
+
+### Map lines
+
+    <start>-<end> <dest>[,<dest>...]
+    <start> <dest>            # a single chunk may omit "-<end>"
+
+- `start`/`end` are chunk ids. Lines ascend, never overlap, and together
+  cover every chunk id in `0..top` exactly once.
+- A destination is `<code>` or `<code>.<item>`:
+  - `code` is a letter code from the legend the prompt carries —
+    assigned by the library in unit order; `-` is reserved.
+  - `.item` on a repeating unit is the instance's index, numbered across
+    the WHOLE document in the order the map meets the instances.
+- A bare repeating code (`4-9 x`) means several instances share the run
+  unsplit — that material is extracted once, whole.
+- A run may feed several DIFFERENT units at once, comma-joined
+  (`5 x.0,y.0`) — a summary or cross-cutting unit rides the lines of the
+  unit whose text it shares, item by item.
+- Several items of the SAME unit may share one line (`3 x.0,x.1,x.2`)
+  when chunk boundaries cannot separate the instances.
+- `-` on its own (never comma-joined) marks chunks irrelevant to every
+  unit.
+
+### Declaration lines
+
+After the map, every repeating unit gets exactly one of:
+
+    x: <count> [@<budget>[,<budget>...]]
+    x = <source> [@<budget>]
+
+- `x: <count>` — the document holds `<count>` instances of the unit.
+  Item indexes used in the map must run exactly `0..count-1` with no
+  gaps, and every declared item must receive at least one chunk.
+- `x = <source>` — the unit has no text of its own; its items mirror
+  `<source>`'s, a directly mapped repeating unit. Such a unit takes NO
+  map lines.
+- The budget suffix is tolerated, never validated: one entry per item
+  in item-index order (`@500,300,150`), or one entry covering every item.
+  Three forms: `@<n>` an absolute character cap, `@<n>%` a ratio of the
+  item's mapped material (a verbatim copy is `@100%`), and
+  `@<avg>x<count>` an average keyword length times a keyword count.
+  Malformed entries are dropped silently — the count still parses, no
+  error.
+
+## What validation enforces
+
+Violations are fed back as repair errors (bounded rounds, then
+`RouterError`):
+
+- map lines parse, ascend, do not overlap, and cover `0..top` exactly
+- the item set each unit uses in the map equals `0..declared-1`
+- every repeating unit is declared (a missing declaration reads as 0,
+  which triggers a separate fresh-conversation recount before it is
+  trusted)
+- a derivation's `source` is itself a directly mapped repeating unit
+
+Tolerated noise: counts on non-array units are ignored; an exact
+duplicate map line collapses; a dotted tail on an item (`2.0`) keeps its
+leading index.
+
+## Budgets
+
+The suffix is the router's arrangement — its estimate of the characters
+each item's output JSON will run to (keys and punctuation included).
+It declares the estimate in the form that matches the extraction's
+shape:
+
+- `@<n>` — an absolute cap, for fixed-length summaries and anything
+  else.
+- `@<n>%` — a ratio of the item's mapped material, for verbatim or
+  unbounded-refinement extraction (`@100%` is a verbatim copy; one
+  shared ratio scales per item against each item's own material). The
+  resolved estimate adds the item schema's skeleton (key names and
+  punctuation, computed from the schema) on top — the ratio covers the
+  content, the structure is code-known.
+- `@<avg>x<count>` — an average keyword length times the document's
+  keyword count, for lists of short same-shaped entries. One shared
+  entry is the document-level total: the resolver splits it across the
+  items it covers.
+
+The library resolves every form to absolute characters against the
+routed material before use; the declared forms ride in the trace's
+router budgets verbatim. Budgets shape output through batch scheduling
+(consecutive small items coalesce into one shared call while their
+accumulated budget fits the per-call capacity) and are never enforced
+on the output. Overruns are accepted — a retry would cost a full
+extra decode. A host's `output_budgets={'path': n | [n, ...]}`
+overrides the router's declarations per path.

xtremeparse-0.1.0/docs/prompting.md

@@ -0,0 +1,90 @@
+# Prompt overrides
+
+xtremeparse ships measured default prompts. They are replaceable — real
+effectiveness ultimately depends on the host's schema and eval — but an
+override is an escape hatch for domain/model/language adaptation, not
+the primary tuning path.
+
+## Layering order (measured)
+
+1. **Schema `description`s first.** Field-level semantics live in the
+   schema the host passes in: unit cards and legends are composed from
+   them, and field fidelity follows the description's wording (a
+   fidelity clause in a field description moves output where generic
+   prompt rules never did).
+2. **Prompt overrides second.** For adapting the generic extraction
+   discipline to a new document domain, a weaker model, or another
+   language.
+3. **Never** the DSL ([dsl.md](dsl.md)) or the validation / recount /
+   correction loops — that machinery is the library's core contract.
+
+## The three slots
+
+```python
+Extractor(runner,
+          router_instructions=...,      # the segment-map prompt
+          recount_instructions=...,     # the zero-unit recount prompt
+          specialist_instructions=...)  # the extraction prompt
+```
+
+| kwarg | placeholders |
+|---|---|
+| `router_instructions` | `top`, `none`, `legend`, `chunks` |
+| `recount_instructions` | `legend`, `chunks` |
+| `specialist_instructions` | `card` |
+
+- Templates are `str.format` strings. Required placeholders are
+  validated at construction: a template missing one raises `ValueError`
+  instead of silently rendering a prompt without its chunk listing.
+- `top` is the highest chunk id, `none` the NONE marker, `chunks` the
+  numbered chunk listing, `card` the unit's semantic card — all built by
+  code. `legend` is one `code = <unit card header>` line per unit; its
+  format is fixed by code (the card header is the cue the default
+  prompts rely on — an override legend interpretation is the override's
+  to keep consistent).
+- Correction rounds re-dispatch with the same override automatically —
+  a correction round continues the original call's conversation history.
+- The judge prompt (`xtremeparse.judging.judge(instructions=...)`) is
+  overridable the same way — one placeholder, `rubric`.
+
+## Judging (measured guidance)
+
+Judge-side settings live at the adapter, as recommendations:
+
+- A model other than the extraction fleet's tends to read kinder to
+  self-judging bias.
+- Temperature 0 steadies verdicts (a judge that flips run to run
+  measures noise, not quality).
+
+Shape the judged material before trusting exclusion clauses — a judge
+shown field structure keeps demanding a field-for-field mirror of the
+source even against explicit exclusions, measured across models and
+reasoning modes. For containment questions (is every fact anywhere?),
+judge the host's flattened-digest projection and carry the schema's
+field inventory in the rubric. The open-diff judge measures
+~zero sensitivity to seeded deletions — presence checking belongs to
+deterministic anchors beside it, not to the judge alone.
+
+## Provenance
+
+`result.trace.prompts` marks every slot `'default'` or `#<sha1-8>` of
+the host's template, so eval regressions stay attributable to whose
+prompt produced them.
+
+## Not overridable
+
+- The budget suffix handling — the router's arrangement forms are
+  resolved and consumed by code, not by prompt wording.
+- Repair and recount feedback messages — generated from validation
+  errors, not prose.
+- The shared payload prefix (`content`) — byte-identical across every
+  call of one extraction; the provider KV cache depends on it.
+
+## Stability caveat
+
+The defaults carry measured calibration: map-before-count (a count-first
+declaration made models drop a section's tail entry), card-header
+legends (bare paths cost recognition), form-matched budget declarations
+(ratio by default, keyword and absolute for their shapes). An override
+discards all of it. A/B against the default on a frozen corpus
+before shipping one.

xtremeparse-0.1.0/pyproject.toml

@@ -0,0 +1,55 @@
+[project]
+name = 'xtremeparse'
+description = 'XtremeParse: extreme-concurrency structured extraction — chunk, route, fan out, self-correct'
+readme = 'README.md'
+requires-python = '>=3.9'
+license = 'MIT'
+authors = [
+    {name = 'Flow Jiang', email = 'flowjzh@gmail.com'},
+]
+keywords = ['llm', 'extraction', 'json-schema', 'concurrency', 'structured-data', 'parsing']
+classifiers = [
+    'Development Status :: 3 - Alpha',
+    'Intended Audience :: Developers',
+    'Topic :: Software Development :: Libraries :: Python Modules',
+    'Programming Language :: Python :: 3',
+    'Programming Language :: Python :: 3.9',
+    'Programming Language :: Python :: 3.10',
+    'Programming Language :: Python :: 3.11',
+    'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
+    'Programming Language :: Python :: 3 :: Only',
+    'Operating System :: OS Independent',
+    'Typing :: Typed',
+]
+dependencies = [
+    'xtremeflow>=0.1.0',
+]
+dynamic = ["version"]
+
+[project.optional-dependencies]
+evals = [
+    'pydantic-evals',
+]
+
+[dependency-groups]
+dev = [
+    'pytest>=8.4.2',
+    'pytest-asyncio>=0.24.0',
+    'pydantic-evals',
+]
+
+[project.urls]
+Homepage = 'https://github.com/flowjzh/xtremeparse'
+Repository = 'https://github.com/flowjzh/xtremeparse.git'
+Issues = 'https://github.com/flowjzh/xtremeparse/issues'
+
+[build-system]
+requires = ["hatchling", "uv-dynamic-versioning"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "uv-dynamic-versioning"
+
+[tool.uv.sources]
+xtremeflow = { workspace = true }

xtremeparse-0.1.0/pytest.ini

@@ -0,0 +1,2 @@
+[pytest]
+asyncio_mode = auto

xtremeparse-0.1.0/tests/__init__.py

@@ -0,0 +1 @@
+"""Boundary-probe test suite."""

xtremeparse-0.1.0/tests/helpers.py

@@ -0,0 +1,5 @@
+"""Shared test doubles: owned by the protocol owner."""
+
+from xtremeparse.testing import FakeIssue, ScriptedRunner, agent_result
+
+__all__ = ['FakeIssue', 'ScriptedRunner', 'agent_result']

xtremeparse-0.1.0/tests/test_chunking.py

@@ -0,0 +1,90 @@
+"""Boundary probes for the deterministic chunker."""
+
+from xtremeparse.chunking import chunk_text
+
+
+def test_empty_and_whitespace_only():
+    assert chunk_text('') == []
+    assert chunk_text('   \n\t \n\n') == []
+
+
+def test_tiny_input_is_one_chunk():
+    assert chunk_text('姓名') == ['姓名']
+
+
+def test_plain_hard_wrapped_lines_form_one_paragraph_chunk():
+    text = '姓名：张三\n年龄：30\n电话：13800000000'
+    assert chunk_text(text) == [text]
+
+
+def test_blank_lines_separate_paragraphs():
+    assert chunk_text('第一段\n\n第二段\n \n第三段') == ['第一段', '第二段', '第三段']
+
+
+def test_heading_opens_block_absorbing_following_plain_lines():
+    text = '## 工作经历\n2020-2023 腾讯 后端'
+    assert chunk_text(text) == [text]
+
+
+def test_list_items_and_numbered_items_are_individual_chunks():
+    text = '经历：\n- 腾讯 后端\n• 阿里 高级专家\n1. 早期创业\n2、外企'
+    assert chunk_text(text) == ['经历：', '- 腾讯 后端', '• 阿里 高级专家', '1. 早期创业', '2、外企']
+
+
+def test_negative_numbers_are_not_list_items():
+    assert chunk_text('-10分\n正常行') == ['-10分\n正常行']
+
+
+def test_line_leading_dates_are_not_list_items():
+    text = '2015.3 joined 腾讯\n2018.5 left'
+    assert chunk_text(text) == [text]
+
+
+def test_table_rows_are_individual_chunks():
+    text = '|公司|职位|\n|---|---|\n|腾讯|后端|'
+    assert chunk_text(text) == ['|公司|职位|', '|---|---|', '|腾讯|后端|']
+
+
+def test_sentences_split_and_pack_to_ceiling():
+    text = '第一句。' * 300  # 300 four-char sentences, 1200 chars
+    chunks = chunk_text(text, max_chars=200)
+    assert all(len(c) <= 200 for c in chunks)
+    assert len(chunks) == -(-len(text) // 200)  # minimal packing, no slack
+    assert ''.join(chunks) == text
+
+
+def test_fullwidth_full_stop_is_a_sentence_ender():
+    chunks = chunk_text('第一段．第二段．', max_chars=6)
+    assert chunks == ['第一段．', '第二段．']
+
+
+def test_digit_dots_never_split_but_sentence_dots_do():
+    chunks = chunk_text('Joined 2015.3. Left 2018.5.', max_chars=15)
+    assert chunks == ['Joined 2015.3.', ' Left 2018.5.']
+
+
+def test_unpunctuated_line_falls_to_character_windows():
+    assert chunk_text('密' * 1300, max_chars=600) == ['密' * 600, '密' * 600, '密' * 100]
+
+
+def test_dense_block_inside_markdown_uses_windows_but_keeps_heading():
+    text = f'## 经历\n{"密" * 700}\n\n## 其他\n简短'
+    chunks = chunk_text(text, max_chars=600)
+    assert ''.join(chunks[:2]) == f'## 经历\n{"密" * 700}'  # dense block windowed whole
+    assert chunks[0].startswith('## 经历\n')
+    assert chunks[2] == '## 其他\n简短'
+
+
+def test_crlf_is_normalized():
+    assert chunk_text('第一段\r\n\r\n第二段') == ['第一段', '第二段']
+
+
+def test_deterministic_and_ordered_substrings():
+    text = '# 简历\n张三，30岁\n\n## 经历\n- 腾讯 后端\n\n自我介绍。很长。'
+    first, second = chunk_text(text), chunk_text(text)
+    assert first == second
+    pos = 0
+    for chunk in first:
+        i = text.find(chunk, pos)
+        assert i >= 0, 'chunks must be ordered substrings'
+        pos = i + len(chunk)

xtremeparse-0.1.0/tests/test_contracts.py

@@ -0,0 +1,27 @@
+"""Contracts stay vendor-neutral and structurally compatible."""
+
+from xtremeparse.contracts import AgentResult, AgentRunner, ExtractionResult, Issue, Trace
+from tests.helpers import FakeIssue
+
+
+class FakeRunner:
+    async def run(self, **kwargs):
+        return AgentResult(data={}, history=[])
+
+
+def test_host_issue_conforms_without_adaptation():
+    issue = FakeIssue(path='basic_info.name', message='required', code='missing_required',
+                      expected=['a', 'b'])
+    assert isinstance(issue, Issue)
+
+
+def test_runner_protocol_is_structural():
+    assert isinstance(FakeRunner(), AgentRunner)
+
+
+def test_result_holds_opaque_parts():
+    issues = [FakeIssue(path='career', message='empty', code='missing_required')]
+    result = ExtractionResult(data={'basic_info': {}}, issues=issues, trace=Trace())
+    assert result.data == {'basic_info': {}}
+    assert result.issues[0].path == 'career'
+    assert result.trace.chunks == []