code-puppy-core 0.1.0__tar.gz

code_puppy_core-0.1.0/Cargo.toml

@@ -0,0 +1,13 @@
+[workspace]
+members = ["code_puppy_core"]
+resolver = "2"
+
+[workspace.dependencies]
+pyo3 = { version = "0.28", features = ["extension-module", "abi3-py311"] }
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+
+[profile.release]
+opt-level = 3
+lto = true
+codegen-units = 1

code_puppy_core-0.1.0/PKG-INFO

@@ -0,0 +1,4 @@
+Metadata-Version: 2.4
+Name: code-puppy-core
+Version: 0.1.0
+Requires-Python: >=3.11

code_puppy_core-0.1.0/code_puppy_core/.gitignore

@@ -0,0 +1,7 @@
+/target/
+/.venv/
+*.so
+*.dylib
+*.pyd
+__pycache__/
+*.egg-info/

code_puppy_core-0.1.0/code_puppy_core/Cargo.lock

@@ -0,0 +1,245 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "code_puppy_core"
+version = "0.1.0"
+dependencies = [
+ "pyo3",
+ "rmp-serde",
+ "rustc-hash",
+ "serde",
+ "serde_json",
+ "xxhash-rust",
+]
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "itoa"
+version = "1.0.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
+
+[[package]]
+name = "libc"
+version = "0.2.183"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5b646652bf6661599e1da8901b3b9522896f01e736bad5f723fe7a3a27f899d"
+
+[[package]]
+name = "memchr"
+version = "2.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8ca58f447f06ed17d5fc4043ce1b10dd205e060fb3ce5b979b8ed8e59ff3f79"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
+
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf85e27e86080aafd5a22eae58a162e133a589551542b3e5cee4beb27e54f8e1"
+dependencies = [
+ "libc",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8bf94ee265674bf76c09fa430b0e99c26e319c945d96ca0d5a8215f31bf81cf7"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "491aa5fc66d8059dd44a75f4580a2962c1862a1c2945359db36f6c2818b748dc"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f5d671734e9d7a43449f8480f8b38115df67bef8d21f76837fa75ee7aaa5e52e"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.28.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22faaa1ce6c430a1f71658760497291065e6450d7b5dc2bcf254d49f66ee700a"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41f2619966050689382d2b44f664f4bc593e129785a36d6ee376ddf37259b924"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rmp"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ba8be72d372b2c9b35542551678538b562e7cf86c3315773cae48dfbfe7790c"
+dependencies = [
+ "num-traits",
+]
+
+[[package]]
+name = "rmp-serde"
+version = "1.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72f81bee8c8ef9b577d1681a70ebbc962c232461e397b22c208c43c04b67a155"
+dependencies = [
+ "rmp",
+ "serde",
+]
+
+[[package]]
+name = "rustc-hash"
+version = "2.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.149"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
+dependencies = [
+ "itoa",
+ "memchr",
+ "serde",
+ "serde_core",
+ "zmij",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.117"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e665b8803e7b1d2a727f4023456bbbbe74da67099c585258af0ad9c5013b9b99"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
+
+[[package]]
+name = "xxhash-rust"
+version = "0.8.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdd20c5420375476fbd4394763288da7eb0cc0b8c11deed431a91562af7335d3"
+
+[[package]]
+name = "zmij"
+version = "1.0.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8848ee67ecc8aedbaf3e4122217aff892639231befc6a1b58d29fff4c2cabaa"

code_puppy_core-0.1.0/code_puppy_core/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "code_puppy_core"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "_code_puppy_core"
+crate-type = ["cdylib"]
+
+[dependencies]
+pyo3 = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+rustc-hash = "2"
+rmp-serde = "1"
+xxhash-rust = { version = "0.8", features = ["xxh32"] }

code_puppy_core-0.1.0/code_puppy_core/src/hashline.rs

@@ -0,0 +1,199 @@
+/// Hashline: file-edit anchoring via per-line content hashes.
+///
+/// Each line gets a 2-char anchor encoded with NIBBLE_STR so the LLM can
+/// reference lines precisely. Compatible with oh-my-pi's hashline format.
+
+// Custom nibble encoding (matches omp's NIBBLE_STR)
+const NIBBLE_STR: &[u8; 16] = b"ZPMQVRWSNKTXJBYH";
+
+/// Compute a 2-character hash anchor for a single line.
+///
+/// Algorithm:
+/// 1. Strip trailing whitespace / `\r`
+/// 2. If line has no alphanumeric chars → seed = idx, else seed = 0
+/// 3. xxHash32 of cleaned line bytes with that seed
+/// 4. Take lowest byte of hash
+/// 5. Encode via NIBBLE_STR: high nibble char + low nibble char
+pub fn compute_line_hash(idx: u32, line: &str) -> String {
+    // Strip trailing whitespace and \r
+    let cleaned = line.trim_end_matches(|c: char| c == '\r' || c.is_whitespace());
+
+    // Check if line has any alphanumeric character (Unicode-aware)
+    let has_alnum = cleaned.chars().any(|c| c.is_alphanumeric());
+
+    let seed = if has_alnum { 0u32 } else { idx };
+
+    let hash = xxhash_rust::xxh32::xxh32(cleaned.as_bytes(), seed);
+
+    let byte = (hash & 0xFF) as usize;
+    let hi = NIBBLE_STR[(byte >> 4) & 0xF] as char;
+    let lo = NIBBLE_STR[byte & 0xF] as char;
+
+    format!("{}{}", hi, lo)
+}
+
+/// Format text with hashline prefixes.
+///
+/// Each line becomes `{line_number}#{hash}:{original_line}`.
+/// `start_line` is 1-based by convention.
+pub fn format_hashlines(text: &str, start_line: u32) -> String {
+    text.split('\n')
+        .enumerate()
+        .map(|(i, line)| {
+            let line_num = start_line + i as u32;
+            let hash = compute_line_hash(line_num, line);
+            format!("{}#{}:{}", line_num, hash, line)
+        })
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+/// Strip hashline prefixes from text, returning plain content.
+///
+/// Lines matching `^\d+#[A-Z]{2}:` have the prefix removed.
+/// Other lines pass through unchanged.
+pub fn strip_hashline_prefixes(text: &str) -> String {
+    text.split('\n')
+        .map(|line| strip_one_hashline_prefix(line))
+        .collect::<Vec<_>>()
+        .join("\n")
+}
+
+fn strip_one_hashline_prefix(line: &str) -> &str {
+    // Fast path: find '#', verify digits before it, 2 uppercase after, then ':'
+    let Some(hash_pos) = line.find('#') else {
+        return line;
+    };
+
+    // Everything before '#' must be digits
+    if !line[..hash_pos].chars().all(|c| c.is_ascii_digit()) || hash_pos == 0 {
+        return line;
+    }
+
+    let after_hash = &line[hash_pos + 1..];
+
+    // Need at least 3 chars: 2 uppercase + ':'
+    if after_hash.len() < 3 {
+        return line;
+    }
+
+    let bytes = after_hash.as_bytes();
+    if bytes[0].is_ascii_uppercase() && bytes[1].is_ascii_uppercase() && bytes[2] == b':' {
+        &after_hash[3..]
+    } else {
+        line
+    }
+}
+
+/// Validate that a stored hash anchor still matches the current line content.
+pub fn validate_hashline_anchor(idx: u32, line: &str, expected_hash: &str) -> bool {
+    compute_line_hash(idx, line) == expected_hash
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_nibble_encoding_range() {
+        // All 256 possible byte values should produce 2 uppercase chars in NIBBLE_STR
+        for byte in 0u8..=255 {
+            let hi = NIBBLE_STR[(byte >> 4) as usize] as char;
+            let lo = NIBBLE_STR[(byte & 0xF) as usize] as char;
+            assert!(hi.is_ascii_uppercase(), "hi nibble not uppercase for byte {byte}");
+            assert!(lo.is_ascii_uppercase(), "lo nibble not uppercase for byte {byte}");
+        }
+    }
+
+    #[test]
+    fn test_compute_line_hash_returns_two_chars() {
+        let h = compute_line_hash(1, "hello world");
+        assert_eq!(h.len(), 2);
+        assert!(h.chars().all(|c| c.is_ascii_uppercase()));
+    }
+
+    #[test]
+    fn test_compute_line_hash_whitespace_only_uses_idx_as_seed() {
+        // Two different indices should produce different hashes for whitespace-only lines
+        let h1 = compute_line_hash(1, "   ");
+        let h2 = compute_line_hash(2, "   ");
+        // They *may* collide (only 256 values), but with different seeds the raw
+        // xxh32 values differ, so this is a sanity check that seeds are applied.
+        // We just verify the hashes are valid 2-char strings.
+        assert_eq!(h1.len(), 2);
+        assert_eq!(h2.len(), 2);
+    }
+
+    #[test]
+    fn test_compute_line_hash_strips_trailing_whitespace() {
+        let h1 = compute_line_hash(1, "hello");
+        let h2 = compute_line_hash(1, "hello   ");
+        assert_eq!(h1, h2, "trailing whitespace should be stripped before hashing");
+    }
+
+    #[test]
+    fn test_format_hashlines_basic() {
+        let result = format_hashlines("foo\nbar", 1);
+        let lines: Vec<&str> = result.split('\n').collect();
+        assert_eq!(lines.len(), 2);
+        assert!(lines[0].starts_with("1#"));
+        assert!(lines[0].contains(":foo"));
+        assert!(lines[1].starts_with("2#"));
+        assert!(lines[1].contains(":bar"));
+    }
+
+    #[test]
+    fn test_format_hashlines_start_line() {
+        let result = format_hashlines("hello", 10);
+        assert!(result.starts_with("10#"));
+        assert!(result.ends_with(":hello"));
+    }
+
+    #[test]
+    fn test_strip_hashline_prefixes_roundtrip() {
+        let original = "line one\nline two\n";
+        let formatted = format_hashlines(original, 1);
+        let stripped = strip_hashline_prefixes(&formatted);
+        assert_eq!(stripped, original);
+    }
+
+    #[test]
+    fn test_strip_hashline_prefixes_passthrough() {
+        // Lines without hashline prefix pass through unchanged
+        let text = "no prefix here\njust plain text";
+        let stripped = strip_hashline_prefixes(text);
+        assert_eq!(stripped, text);
+    }
+
+    #[test]
+    fn test_strip_mixed_lines() {
+        let formatted = format_hashlines("hello", 1);
+        let mixed = format!("{}\nplain line", formatted);
+        let stripped = strip_hashline_prefixes(&mixed);
+        assert_eq!(stripped, "hello\nplain line");
+    }
+
+    #[test]
+    fn test_validate_hashline_anchor_valid() {
+        let h = compute_line_hash(5, "some code");
+        assert!(validate_hashline_anchor(5, "some code", &h));
+    }
+
+    #[test]
+    fn test_validate_hashline_anchor_invalid() {
+        let h = compute_line_hash(5, "some code");
+        assert!(!validate_hashline_anchor(5, "different code", &h));
+    }
+
+    #[test]
+    fn test_validate_hashline_anchor_wrong_idx_for_blank() {
+        // Blank line hashes depend on idx — validate round-trip consistency
+        let h1 = compute_line_hash(1, "");
+        let h2 = compute_line_hash(100, "");
+        // Each hash should validate correctly for its own idx
+        assert!(validate_hashline_anchor(1, "", &h1));
+        assert!(validate_hashline_anchor(100, "", &h2));
+        // And the hash for idx=1 must NOT validate as idx=1 with wrong content
+        assert!(!validate_hashline_anchor(1, "x", &h1));
+    }
+}

code_puppy_core-0.1.0/code_puppy_core/src/lib.rs

@@ -0,0 +1,182 @@
+use pyo3::prelude::*;
+use pyo3::types::PyList;
+
+mod hashline;
+mod message_hashing;
+mod pruning;
+mod serialization;
+mod token_estimation;
+mod types;
+
+use hashline::{
+    compute_line_hash as compute_line_hash_impl,
+    format_hashlines as format_hashlines_impl,
+    strip_hashline_prefixes as strip_hashline_prefixes_impl,
+    validate_hashline_anchor as validate_hashline_anchor_impl,
+};
+use pruning::{prune_and_filter_impl, split_for_summarization_impl, truncation_indices_impl};
+use serialization::{
+    deserialize_session_impl, serialize_session_impl, serialize_session_incremental_impl,
+};
+use token_estimation::process_messages_batch_impl;
+
+// ── Result types exposed to Python ──────────────────────────────────────────
+
+#[pyclass(frozen)]
+#[derive(Debug)]
+pub struct ProcessResult {
+    #[pyo3(get)]
+    pub per_message_tokens: Vec<i64>,
+    #[pyo3(get)]
+    pub total_message_tokens: i64,
+    #[pyo3(get)]
+    pub context_overhead_tokens: i64,
+    #[pyo3(get)]
+    pub message_hashes: Vec<i64>,
+}
+
+#[pyclass(frozen)]
+#[derive(Debug)]
+pub struct PruneResult {
+    #[pyo3(get)]
+    pub surviving_indices: Vec<usize>,
+    #[pyo3(get)]
+    pub dropped_count: usize,
+    #[pyo3(get)]
+    pub had_pending_tool_calls: bool,
+    #[pyo3(get)]
+    pub pending_tool_call_count: usize,
+}
+
+#[pyclass(frozen)]
+#[derive(Debug)]
+pub struct SplitResult {
+    #[pyo3(get)]
+    pub summarize_indices: Vec<usize>,
+    #[pyo3(get)]
+    pub protected_indices: Vec<usize>,
+    #[pyo3(get)]
+    pub protected_token_count: i64,
+}
+
+// ── Helper: parse list[dict] → Vec<Message> ─────────────────────────────────
+
+// ── Python-facing functions ─────────────────────────────────────────────────
+
+#[pyfunction]
+#[pyo3(signature = (messages, tool_definitions, mcp_tool_definitions, system_prompt))]
+fn process_messages_batch<'py>(
+    messages: &Bound<'py, PyList>,
+    tool_definitions: &Bound<'py, PyList>,
+    mcp_tool_definitions: &Bound<'py, PyList>,
+    system_prompt: &str,
+) -> PyResult<ProcessResult> {
+    process_messages_batch_impl(
+        messages,
+        tool_definitions,
+        mcp_tool_definitions,
+        system_prompt,
+    )
+}
+
+#[pyfunction]
+#[pyo3(signature = (messages, max_tokens_per_message=50000))]
+fn prune_and_filter(
+    messages: &Bound<'_, PyList>,
+    max_tokens_per_message: i64,
+) -> PyResult<PruneResult> {
+    prune_and_filter_impl(messages, max_tokens_per_message)
+}
+
+#[pyfunction]
+#[pyo3(signature = (per_message_tokens, protected_tokens, second_has_thinking))]
+fn truncation_indices(
+    per_message_tokens: Vec<i64>,
+    protected_tokens: i64,
+    second_has_thinking: bool,
+) -> PyResult<Vec<usize>> {
+    Ok(truncation_indices_impl(
+        &per_message_tokens,
+        protected_tokens,
+        second_has_thinking,
+    ))
+}
+
+#[pyfunction]
+#[pyo3(signature = (per_message_tokens, tool_call_ids_per_message, protected_tokens_limit))]
+fn split_for_summarization(
+    per_message_tokens: Vec<i64>,
+    tool_call_ids_per_message: Vec<Vec<(String, String)>>,
+    protected_tokens_limit: i64,
+) -> PyResult<SplitResult> {
+    Ok(split_for_summarization_impl(
+        &per_message_tokens,
+        &tool_call_ids_per_message,
+        protected_tokens_limit,
+    ))
+}
+
+#[pyfunction]
+#[pyo3(signature = (messages,))]
+fn serialize_session(messages: &Bound<'_, PyList>) -> PyResult<Vec<u8>> {
+    serialize_session_impl(messages)
+}
+
+#[pyfunction]
+#[pyo3(signature = (data,))]
+fn deserialize_session<'py>(data: &[u8], py: Python<'py>) -> PyResult<Py<PyList>> {
+    deserialize_session_impl(py, data)
+}
+
+#[pyfunction]
+#[pyo3(signature = (new_messages, existing_data=None))]
+fn serialize_session_incremental(
+    new_messages: &Bound<'_, PyList>,
+    existing_data: Option<&[u8]>,
+) -> PyResult<Vec<u8>> {
+    serialize_session_incremental_impl(new_messages, existing_data)
+}
+
+// ── Hashline functions ──────────────────────────────────────────────────────
+
+#[pyfunction]
+fn compute_line_hash(idx: u32, line: &str) -> String {
+    compute_line_hash_impl(idx, line)
+}
+
+#[pyfunction]
+#[pyo3(signature = (text, start_line=1))]
+fn format_hashlines(text: &str, start_line: u32) -> String {
+    format_hashlines_impl(text, start_line)
+}
+
+#[pyfunction]
+fn strip_hashline_prefixes(text: &str) -> String {
+    strip_hashline_prefixes_impl(text)
+}
+
+#[pyfunction]
+fn validate_hashline_anchor(idx: u32, line: &str, expected_hash: &str) -> bool {
+    validate_hashline_anchor_impl(idx, line, expected_hash)
+}
+
+// ── Module registration ─────────────────────────────────────────────────────
+
+#[pymodule]
+fn _code_puppy_core(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<ProcessResult>()?;
+    m.add_class::<PruneResult>()?;
+    m.add_class::<SplitResult>()?;
+    m.add_function(wrap_pyfunction!(process_messages_batch, m)?)?;
+    m.add_function(wrap_pyfunction!(prune_and_filter, m)?)?;
+    m.add_function(wrap_pyfunction!(truncation_indices, m)?)?;
+    m.add_function(wrap_pyfunction!(split_for_summarization, m)?)?;
+    m.add_function(wrap_pyfunction!(serialize_session, m)?)?;
+    m.add_function(wrap_pyfunction!(deserialize_session, m)?)?;
+    m.add_function(wrap_pyfunction!(serialize_session_incremental, m)?)?;
+    m.add_function(wrap_pyfunction!(compute_line_hash, m)?)?;
+    m.add_function(wrap_pyfunction!(format_hashlines, m)?)?;
+    m.add_function(wrap_pyfunction!(strip_hashline_prefixes, m)?)?;
+    m.add_function(wrap_pyfunction!(validate_hashline_anchor, m)?)?;
+    Ok(())
+}