Skip to main content

text_chipper

Rust Version Python License: Apache 2.0 Version

High-performance, Markdown-aware, strictly budget-enforced text chunking for RAG and LLM pipelines. Built in Rust with Python bindings.

  • Token-exact budget. In the default strict mode every chunk is re-tokenized exactly as it will be delivered (header context included), so token_count <= max_length always holds.

  • Structure-aware. Text is divided at blank lines into blocks that are packed into chunks and split internally only when a block does not fit. Fenced code blocks and list items are kept intact when they fit, and headings become headers metadata for each chunk. See Markdown support for exactly what is and is not recognized.

  • Never cuts inside a grapheme cluster (emoji sequences, combining marks).

  • Offsets map back to your input, even when Unicode normalization (NFC/NFKC) is applied.

  • Block boundaries are compared against pulldown-cmark on the CommonMark 0.31.2 spec corpus (results and limits below); there are also property tests and a robustness suite. This is a chunker, not a complete CommonMark parser.


⚡ Quick Start

pip install text-chipper

Not on PyPI yet? Build from source, see Installation from source.

from text_chipper import TextChipper

chipper = TextChipper(max_length=512, overlap=50, encoding="cl100k_base")

for chunk in chipper.chunk(open("README.md", encoding="utf-8").read()):
    print(chunk.token_count, chunk.headers)   # e.g. 487 ['Install', 'From source']
    print(chunk.contextualized_text)          # "[ctx:Install > From source] ..." + text

Other entry points: chunk_batch(texts), from_file(path), from_files(paths), from_file_stream(path) (an iterator), count_tokens(text).

Each TextChunk has text, headers, contextualized_text, token_count, character/byte offsets in the normalized text (start_index, end_index, start_byte, end_byte) and in your original input (orig_start_index, orig_end_index, orig_start_byte, orig_end_byte).

Adapters for LangChain and LlamaIndex are in integrations/.


🛠️ Scope & Installation

Scope

Supported Not supported
Markdown and plain text, passed as str or read from UTF-8 files HTML, PDF, DOCX loaders
Tokenizers: cl100k_base, o200k_base, p50k_base, r50k_base, chars, words; Hugging Face tokenizer.json (build with the hf feature); any counter you supply from Rust through the Tokenizer trait (see Pluggable tokenizers) Code-aware splitting (no AST, no function/class boundaries)

Convert other formats to Markdown or text before chunking.

Installation from source

Requires a Rust toolchain:

pip install maturin
maturin develop --release        # into the active virtualenv
# or: maturin build --release    # build a wheel into target/wheels/

📖 Chunking modes

include_context=True (default): Markdown-aware

The Markdown block parser runs. Headings are tracked and attached to chunks as headers; the label [ctx:A > B] counts against max_length (at most about a quarter of the budget is reserved for it). Fenced code blocks and list items stay intact when they fit, and adjacent blocks are packed together while they fit (merge_blocks=True). Tables, block quotes, HTML blocks and indented code get no special handling; see Markdown support.

include_context=False: flat mode

This is not "the same thing without the header prefix". Flat mode does not parse Markdown at all: the text is cut into token windows (honouring overlap) that prefer paragraph, line and word boundaries.

  • Code fences, lists and tables are not protected and can be cut.
  • Headings are ordinary text and headers is always empty; merge_blocks has no effect.
  • chunk() and chunk_batch() always behave this way.
  • from_file, from_files and from_file_stream give exactly the chunks chunk() gives for the file's text, at any size. Flat mode needs the whole file in memory (peak memory is roughly an order of magnitude larger than the file for ASCII text; this is estimated from the data structures, not measured), so files larger than 32 MiB raise OSError instead of being chunked differently. To process bigger files with bounded memory, use include_context=True (streamed), or split the file first.

Use flat mode when you want plain overlapping token windows over arbitrary text; use the default mode for Markdown documents.

📈 Benchmarks

text_chipper is compared with seven other ways of chunking text on the same inputs: 12 workloads (synthetic prose, Markdown and code, real-world texts such as PubMed, finance, Wikipedia and chat logs, and stress cases), 512-token chunks, cl100k_base, no overlap. All charts below show the single-core lane.

Setup: GitHub Actions runner (AMD EPYC 9V74, 2 logical CPUs, 7.7 GB RAM), Python 3.12.16, cold start (every timing is the first and only call in a fresh process), median of 5 rounds. Compared libraries: chonkie 1.7.0, langchain-text-splitters 1.1.3, semchunk 4.1.1, semantic-text-splitter 0.33.2, tiktoken 0.14.0 (plain token window). text_chipper is the default mode (Markdown-aware, strict) and text_chipper (flat) is include_context=False. Results come from one run on a shared virtual machine, so treat the ratios as indicative, especially on the small files (under 120 KiB, where a call takes only a few milliseconds). Method, metric definitions, raw data and the harness are in benchmarks/.

Speed

Throughput averaged over all 12 workloads (geometric mean): text_chipper reaches 25.4 MiB/s, which is 2.0 times the speed of a plain tiktoken token window and 3.3 to 11 times the speed of the other chunking libraries.

Bar chart: geometric-mean throughput of each library over all 12 workloads

text_chipper is the fastest library on 11 of 12 workloads. The exception is stress_cjk_unbroken (a megabyte of CJK text without separators), where it reaches 7.0 MiB/s while tiktoken window (15.8 MiB/s) and chonkie TokenChunker (11.2 MiB/s) are faster. On real_chatlogs (39 KiB, about 3 ms per call) text_chipper and tiktoken window are within noise of each other (14.2 and 13.4 MiB/s).

Heat map: MiB/s of each library on each workload

Memory

Peak memory of the whole Python process (interpreter and imported library included), single core, mean over all workloads. Every library stays between 96 and 104 MB, most of it the interpreter and the tokenizer. text_chipper adds 1.4 MB on average while chunking and about 10 MB on its worst workload.

Bar chart: peak memory of the Python process per library, single core

Chunk quality

Scorecard: token limit, words, source text and code fences per library, with speed

  • Token limit: no text_chipper chunk exceeded 512 tokens on any workload. LangChain went over the limit in up to 16.7 % of chunks (3 of the 18 chunks of real_chatlogs; its largest chunk had 514 tokens), and tiktoken window and chonkie TokenChunker in 2.6 % of the chunks of multilingual (513 tokens). Token counts are measured independently with cl100k_base on the text each library delivers.
  • Words and code: token windows cut words in half (up to 35.5 % of their cut points) and break 21 to 23 % of the small code fences (those that fit in half the budget); chonkie RecursiveChunker breaks about 22 %. text_chipper made one cut inside a word in the whole run (1 of 1,259 cut points in stress_giant_list, none on the other 11 workloads) and kept every small fence whole (392 in markdown_doc, 3,434 in code_heavy).
  • Coverage means the share of the input's non-whitespace text that appears in some chunk. text_chipper (default mode) covers 99.57 % of markdown_doc and 100 % of the other 11 workloads. The 3,613 non-whitespace characters missing from the chunk text of markdown_doc are all heading text, which text_chipper returns in each chunk's headers (and in contextualized_text) instead of the chunk body; counting them, coverage is 100 % and no character is unexplained. text_chipper (flat) covers 100 % everywhere. tiktoken window, chonkie TokenChunker and chonkie RecursiveChunker lose a third (32.6 %) of the unsegmented CJK input, and tiktoken window and chonkie TokenChunker lose 27.6 % of multilingual: their chunks contain replacement characters (U+FFFD) instead of the original text.
  • Chunk ends: semchunk and chonkie RecursiveChunker end slightly more chunks at a sentence or line break on average (91.7 % against 85.9 % for text_chipper). The gap comes mostly from real_wikitexts (43.1 % against 100 %) and real_pubmed (88.2 % against 100 %).

To regenerate the charts after a new benchmark run:

pip install matplotlib
python benchmarks/make_charts.py benchmarks/results/20261112_233503/results.json benchmarks/charts

🔌 Pluggable tokenizers

The chunker only needs one thing from a tokenizer: how many tokens a piece of text has. Built-in backends cover the OpenAI encodings, chars, words and Hugging Face tokenizer.json files (which covers Llama, DeepSeek, Gemini-style and most open models). For anything else, Rust users can supply their own counter by implementing the Tokenizer trait:

use std::sync::Arc;
use text_chipper::{Backend, Tokenizer};

struct MyTokenizer; // wrap SentencePiece, a model-specific BPE, a lookup table, ...

impl Tokenizer for MyTokenizer {
    fn count_tokens(&self, text: &str) -> usize {
        text.split_whitespace().count() // your counting logic
    }
    // Optional, with safe defaults:
    // fn joins_are_additive(&self) -> bool { false }
    // fn initial_ratio(&self) -> f64 { 4.0 }
}

let backend = Backend::from_tokenizer(Arc::new(MyTokenizer));
// or, for a quick closure:
let backend = Backend::from_fn(|text| text.chars().count() / 4);

Pass the resulting Arc<Backend> to SmartChunker, smart_chunk and the other entry points exactly as you would a built-in backend.

Your counter must be:

  • Deterministic: the same text always gives the same count.
  • Monotone on prefixes: count(prefix) <= count(prefix + more). The window search relies on it; strict mode still re-counts every delivered chunk but cannot repair a non-monotone counter.
  • Thread-safe and cheap (Send + Sync): it is called many times per chunk and possibly from several threads, so avoid blocking I/O per call.

joins_are_additive should stay false unless you have verified that count(A + sep + B) <= count(A) + count(sep) + count(B) for newline-terminated separators; with false the chunker keeps a safety slack when merging blocks. initial_ratio (bytes per token) only seeds the window search and affects speed, never correctness.

The Python API does not accept a custom counter yet: use encoding= or tokenizer_file=.

Markdown support and CommonMark conformance

text_chipper is a chunker, not a CommonMark parser. Its block parser decides where a chunk may start or be cut; it does not build a document tree. It reads one line at a time and keeps only bounded state, which is what lets it stream files of any size with exact offsets. It recognizes only what that job needs:

Construct Handling
Text separated by blank lines One block, the unit that is packed into chunks and split last. A paragraph, a table or a block quote with no blank line inside is one block, until a fence or heading line ends it
Fenced code blocks (``` and ~~~, opening fence indented at most three spaces) One block, kept intact when it fits; never scanned for headings
ATX headings (# Title) and short setext headings (at most two lines and 160 characters) Become headers, not body text
YAML (---) and TOML (+++) front matter at the start of a document Kept verbatim as one metadata block; an unterminated one is abandoned after 200 lines or 32 KiB
List items (nested, ordered, lazy continuation, inside block quotes) Located by a dedicated scanner and used as cut points: when a block must be split, item boundaries are preferred over line boundaries, and an item that fits is kept whole, even when blank lines inside it make it several blocks
Tables, block quotes, HTML blocks, indented code, link reference definitions No special handling. They are ordinary text. A long table is cut preferably at line boundaries and its header row is not repeated

Measured agreement with pulldown-cmark

cargo test --features diagnostics commonmark_block_boundary -- --nocapture (after python scripts/fetch_commonmark.py) compares the lines on which our parser starts blocks with the lines on which pulldown-cmark starts top-level blocks, over the 652 examples of the CommonMark 0.31.2 spec. It compares block start lines only: not block contents, end positions or nested structure. ATX headings are left out (they become headers, not blocks) and GFM tables are not part of the corpus.

Measurement Result
Examples where every block start agrees 496 / 652 (76.1 %)
Same, ignoring link reference definitions 567 / 652 (87.0 %)
Our block starts with no reference counterpart 145 / 844 (17.2 %); 70 / 769 (9.1 %) ignoring link reference definitions
Reference block starts we also start (recall) paragraph 96.2 %, code block 96.9 %, HTML block 96.4 %, block quote 92.5 %, list 90.2 %, thematic break 40.6 %

Where we differ from CommonMark, and why

Three differences are deliberate. When choosing them, usefulness of the resulting chunks mattered more than agreement with CommonMark. We have not benchmarked retrieval quality for these choices, so the reasons below are design rationale, not measured results.

  1. Link reference definitions stay text. CommonMark consumes them without producing a block, which accounts for 75 of the 145 extra starts. Chunks must cover the source text, so a definition is ordinary content here.
  2. A blank line always ends a block, even inside lists, indented code and HTML blocks that CommonMark treats as one block. This accounts for 69 of the remaining 70 extra starts (the last one is an edge case involving a link reference definition, example 216). A blank line is the cheapest reliable boundary signal in prose, and it keeps the parser line-oriented without tracking containers. For lists the chunker compensates: an item that fits is kept whole across blank lines (covered by tests). Inside indented code and HTML blocks there is no such compensation, so a blank line there can become a cut point when the block does not fit.
  3. Lists, block quotes, thematic breaks and HTML blocks do not interrupt a paragraph. They start a new block only after a blank line. A line that introduces a list ("Steps:") therefore stays in the same block as the list, and the two are never separated while the block fits. The cost is that a quote or thematic break written directly under a paragraph line belongs to that paragraph's block. All 52 block starts we miss begin directly after a non-blank line, where our parser starts a new block only at a fence or a heading; 32 of them are themselves lists, block quotes, thematic breaks or HTML blocks.

Do not use text_chipper as a CommonMark implementation. If you need an AST or the exact CommonMark block structure, use a Markdown parser and chunk its output.

⚖️ Budget guarantee: strict

strict=True (default) strict=False
Final exact re-count of every delivered chunk yes no
token_count <= max_length guaranteed yes no
token_count exact may be an estimate
A single grapheme cluster larger than the budget raises ValueError returned as its own oversized chunk
Speed slightly slower faster

Use strict mode whenever chunks are fed to an embedding model or a context window with a hard limit. Non-strict mode is a best-effort mode for cases where the budget is only a target.

⚠️ Errors

Every failure is raised as an exception and nothing returns a partial or empty result for bad input:

  • ValueError: invalid configuration, unknown encoding, or (strict mode) a grapheme that does not fit the budget.
  • RuntimeError: the tokenizer backend failed to load (e.g. missing or invalid tokenizer_file).
  • OSError: unreadable file, invalid UTF-8 (unless errors="replace"), a physical line longer than 1 MiB in the streaming reader (include_context=True), or a file larger than 32 MiB in flat mode (include_context=False).
  • chunk_batch and from_files raise the error of the first failing input in input order and return no partial results.

Known limitations

  • Non-strict mode gives no budget guarantee (see above).
  • Flat mode reads whole files (32 MiB limit); streaming with bounded memory is only available with include_context=True.
  • Block recognition is limited to what Markdown support lists. In particular there is no table, block quote or HTML block handling, and a long table is split without repeating its header row.
  • Custom Rust tokenizers are not available from Python yet, and a counter that is not deterministic or not monotone on prefixes can produce suboptimal chunk boundaries.
  • With a Hugging Face tokenizer, a tokenizer failure while counting falls back to the character count (counting has no error channel). This should not happen for valid text; treat counts as best effort in that unlikely case.
  • from_file_stream(..., batch_size_lines=...) accepts but ignores batch_size_lines.

🧪 Development & Testing

cargo test --release                    # unit, oracle, property and robustness tests
pytest tests -v                         # Python binding tests (after `maturin develop`)
python scripts/fetch_commonmark.py      # refresh the pinned CommonMark 0.31.2 corpus
cargo test --features diagnostics commonmark_block_boundary -- --nocapture   # block-boundary agreement report
scripts/run_release_suite.sh          # all tests + diagnostics, with summary
scripts/run_validation.sh             # full validation matrix
pytest benchmarks/tests -q              # self-tests of the benchmark harness

Repository layout: src/ library code; src/tests/ Rust test modules (unit, oracle, parallel, robustness, release suite); tests/ Python binding tests and fixtures; benches/ criterion microbenchmarks; benchmarks/ cross-library benchmark; integrations/ LangChain and LlamaIndex adapters; scripts/ validation and profiling tools.

The long-running reports, stress tests and the release suite are compiled only with the diagnostics feature, so a plain cargo test lists just the regular tests. Run them with cargo test --release --features diagnostics -- --nocapture --test-threads=1, or one at a time by name.

Cargo features: python (default marker), mimalloc (default; disable if your Rust application sets its own global allocator), hf (Hugging Face tokenizers), stats (tokenizer-call profiling, see scripts/profile_tokenizer.py), diagnostics (long-running diagnostic tests and the release suite).

📄 License

Licensed under the Apache License, Version 2.0.

Metadata

Release files for text-chipper 0.2.0

For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.

Source distribution (sdist)

Source distribution for text-chipper 0.2.0
File Size Uploaded Provenance Actions
text_chipper-0.2.0.tar.gz 3.8 MB With provenance Details for text_chipper-0.2.0.tar.gz

Built distributions (wheels)

Table of built distributions (wheels) for text-chipper 0.2.0
File Actions
text_chipper-0.2.0-cp39-abi3-win_amd64.whl CPython 3.9 abi3 Windows x86-64 Details for text_chipper-0.2.0-cp39-abi3-win_amd64.whl
text_chipper-0.2.0-cp39-abi3-musllinux_1_2_x86_64.whl CPython 3.9 abi3 Linux musl 1.2+ x86-64 Details for text_chipper-0.2.0-cp39-abi3-musllinux_1_2_x86_64.whl
text_chipper-0.2.0-cp39-abi3-musllinux_1_2_aarch64.whl CPython 3.9 abi3 Linux musl 1.2+ ARM64 Details for text_chipper-0.2.0-cp39-abi3-musllinux_1_2_aarch64.whl
text_chipper-0.2.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl CPython 3.9 abi3 Linux glibc 2.17+ x86-64 Details for text_chipper-0.2.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
text_chipper-0.2.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl CPython 3.9 abi3 Linux glibc 2.17+ ARM64 Details for text_chipper-0.2.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
text_chipper-0.2.0-cp39-abi3-macosx_11_0_arm64.whl CPython 3.9 abi3 macOS 11.0+ ARM64 Details for text_chipper-0.2.0-cp39-abi3-macosx_11_0_arm64.whl
text_chipper-0.2.0-cp39-abi3-macosx_10_12_x86_64.whl CPython 3.9 abi3 macOS 10.12+ x86-64 Details for text_chipper-0.2.0-cp39-abi3-macosx_10_12_x86_64.whl

Total release size: 22.1 MB

Release files / text_chipper-0.2.0.tar.gz

Download URL text_chipper-0.2.0.tar.gz
Size 3.8 MB
Tags Source
SHA-256 checksum
How to use checksums
6fe532bbb1ca59fa3e2209c82d5d2f269fe94c4f19740c87fc34b6564a66ab30
BLAKE2b-256 checksum
How to use checksums
ff2c83f63c2cde8144608d2184b52b57fa4be4f47d6055a8a6dabbae35ff6568
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-win_amd64.whl

Download URL text_chipper-0.2.0-cp39-abi3-win_amd64.whl
Size 2.5 MB
Tags CPython 3.9 Windows x86-64 abi3
SHA-256 checksum
How to use checksums
343a64e5f46ac70e504a97eb3b99fdf8540615f6a3a549c53748485ca5ab84d3
BLAKE2b-256 checksum
How to use checksums
1175029af7af6414bce7e872f4fb7eac773a191b2f78b9524fbded59a3c4e5d6
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-musllinux_1_2_x86_64.whl

Download URL text_chipper-0.2.0-cp39-abi3-musllinux_1_2_x86_64.whl
Size 2.8 MB
Tags CPython 3.9 Linux musl 1.2+ x86-64 abi3
SHA-256 checksum
How to use checksums
31b2edad2532990508394974ef0aa64656cf744222f48d349f04487c4e833e5c
BLAKE2b-256 checksum
How to use checksums
1de6cf34eb6a9f83738eecebebd768b45ab2d64f42af7522cc476bb9f0a6121f
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-musllinux_1_2_aarch64.whl

Download URL text_chipper-0.2.0-cp39-abi3-musllinux_1_2_aarch64.whl
Size 2.8 MB
Tags CPython 3.9 Linux musl 1.2+ ARM64 abi3
SHA-256 checksum
How to use checksums
f8f469a3cf8a724b3cff2dc7420a0a5aeef572e7e5db7f3da66eaa648e48c65b
BLAKE2b-256 checksum
How to use checksums
6c81343c9a076acd377451952cdab4ad290cbca43998c615a4f67acfc411293b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl

Download URL text_chipper-0.2.0-cp39-abi3-manylinux2014_x86_64.manylinux_2_17_x86_64.whl
Size 2.6 MB
Tags CPython 3.9 Linux glibc 2.17+ x86-64 abi3
SHA-256 checksum
How to use checksums
600dece35627db8053d82fa8b202d0f8d21861fecfd9f5012bf5a476518a3fad
BLAKE2b-256 checksum
How to use checksums
370874f01b17e599b5a61791c744a6a45d1b8a3fbb27912bdd35608fa17263ed
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

Download URL text_chipper-0.2.0-cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl
Size 2.6 MB
Tags CPython 3.9 Linux glibc 2.17+ ARM64 abi3
SHA-256 checksum
How to use checksums
97649553a518d3fe59e5cd511ed27192b01d1a50e3e984f80b4195c9a2355e85
BLAKE2b-256 checksum
How to use checksums
8ae2d1e514167e4414accd8d6f59a0ee07c447eede14f52dbfc00fa3fd1a1ddb
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-macosx_11_0_arm64.whl

Download URL text_chipper-0.2.0-cp39-abi3-macosx_11_0_arm64.whl
Size 2.5 MB
Tags CPython 3.9 abi3 macOS 11.0+ ARM64
SHA-256 checksum
How to use checksums
6bc9eecfcb975a90869f49d37b6bbe2c8cec952f006c0c1135c25090a6d00357
BLAKE2b-256 checksum
How to use checksums
8b3837046bcc705920906beaa586b83d99e225ecc7315f9f4619e2993a78ba6b
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Release files / text_chipper-0.2.0-cp39-abi3-macosx_10_12_x86_64.whl

Download URL text_chipper-0.2.0-cp39-abi3-macosx_10_12_x86_64.whl
Size 2.5 MB
Tags CPython 3.9 abi3 macOS 10.12+ x86-64
SHA-256 checksum
How to use checksums
02f31270aa7ccd379dc68545fba161188d3ace196795b6697aad53e7ba8acc67
BLAKE2b-256 checksum
How to use checksums
f7084daa6c447289f96c1265998e5f90d80cdbf97a0aba6742b66db72458eeed
Upload date
Uploaded using Trusted Publishing?
What is trusted publishing?
Yes
Uploaded via twine/7.0.0 CPython/3.13.16

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

Security for text-chipper 0.2.0

Provenance

Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.

Full provenance

All 8 files in this release have been uploaded with provenance metadata.

Select from 8 files

Attestation for text_chipper-0.2.0.tar.gz

PyPI Publish Attestation

PyPI verified that this artifact, at this checksum, originated from the publisher listed below.

Signed by GitHub Actions, verified by PyPI on Nov 13, 2026.

Transparency log

A note on package security

PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.

To learn more about protecting yourself from malicious actors, visit our package security documentation.

Anthropic, PBC Visionary sponsor Bloomberg Visionary sponsor Hudson River Trading Visionary sponsor Meta Visionary sponsor NVIDIA Visionary sponsor Microsoft Sustainability sponsor Depot Continuous Integration AWS Cloud computing and Security Sponsor Datadog Monitoring Fastly CDN Google Download Analytics Sentry Error logging StatusPage Status page