AI-Powered Rewrite from Python to Rust - part 4

  Add Hypothesis property-based testing to verify that the Python LogParser and RustLogParser produce identical results for any input. Add hypothesis to the dev dependencies in pyproject.toml.

  Create Hypothesis strategies in test_log_parser.py that can generate:
  - Random timestamps in all 4 supported formats with arbitrary dates
  - Random log levels with/without brackets
  - Random field key=value pairs covering all types (integers, floats, booleans, unquoted strings, quoted strings with Unicode)
  - Complete valid log lines (timestamp + level + fields)
  - Noise lines (empty, whitespace, -- ... -- separators)
  - Full log files mixing valid lines, noise, and garbage text

  Exclude surrogate characters (Cs Unicode category) from all text strategies since they can't be written to files.

  Add a TestImplementationsAgree class (separate from the contract classes) with two tests, 500 examples each:
  1. test_both_implementations_agree -- generates a multi-line log file, parses with both implementations, asserts every entry matches (timestamp, level, fields, raw)
  2. test_valid_log_lines_agree -- generates a single valid log line, asserts both implementations produce identical output

  If any Hypothesis failure reveals a bug in the Rust implementation, fix it and re-run until all tests pass. After rebuilding Rust with uv run maturin develop, make sure the new .so is installed correctly before running tests (use uv pip install -e . --force-reinstall --no-build-isolation if uv run pytest picks up a stale binary).

from datetime import datetime
from hypothesis import given, settings, strategies as st

LEVELS = ["INFO", "ERROR", "WARN", "DEBUG", "TRACE", "FATAL"]

st_timestamp = st.one_of(
    st.builds(
        lambda dt: dt.strftime("%Y-%m-%dT%H:%M:%S.") + f"{dt.microsecond:06d}Z",
        st.datetimes(
            min_value=datetime(1970, 1, 1),
            max_value=datetime(2099, 12, 31),
        ),
    ),
    st.builds(
        lambda dt: dt.strftime("%Y-%m-%dT%H:%M:%SZ"),
        st.datetimes(
            min_value=datetime(1970, 1, 1),
            max_value=datetime(2099, 12, 31),
        ),
    ),
    st.builds(
        lambda dt: dt.strftime("%Y-%m-%d %H:%M:%S"),
        st.datetimes(
            min_value=datetime(1970, 1, 1),
            max_value=datetime(2099, 12, 31),
        ),
    ),
    st.builds(
        lambda dt: dt.strftime("%Y/%m/%d %H:%M:%S"),
        st.datetimes(
            min_value=datetime(1970, 1, 1),
            max_value=datetime(2099, 12, 31),
        ),
    ),
)

st_level = st.one_of(
    st.builds(lambda l: f"[{l}]", st.sampled_from(LEVELS)),
    st.sampled_from(LEVELS),
)

st_field_key = st.from_regex(r"[a-z][a-z0-9_]{0,15}", fullmatch=True)

st_field_value = st.one_of(
    st.integers(min_value=-999999, max_value=999999).map(str),
    st.floats(
        min_value=-1e6,
        max_value=1e6,
        allow_nan=False,
        allow_infinity=False,
    ).filter(lambda f: f != int(f)).map(lambda f: f"{f:.2f}"),
    st.sampled_from(["true", "false"]),
    st.text(
        alphabet=st.characters(
            whitelist_categories=("L", "N", "P"),
            blacklist_characters='"\\= \t\n{}',
        ),
        min_size=1,
        max_size=20,
    ),
    st.text(
        alphabet=st.characters(
            whitelist_categories=("L", "N", "P", "Z"),
            blacklist_characters='"\\\n',
        ),
        min_size=1,
        max_size=30,
    ).map(lambda s: f'"{s}"'),
)

st_field = st.builds(lambda k, v: f"{k}={v}", st_field_key, st_field_value)
st_fields = st.lists(st_field, min_size=0, max_size=5).map(lambda fs: " ".join(fs))

st_log_line = st.builds(
    lambda ts, level, fields: f"{ts} {level} {fields}".rstrip(),
    st_timestamp,
    st_level,
    st_fields,
)

st_noise_line = st.one_of(
    st.just(""),
    st.just("   "),
    st.text(
        alphabet=st.characters(blacklist_characters="\n", blacklist_categories=("Cs",)),
        min_size=1,
        max_size=30,
    ).map(lambda s: f"-- {s} --"),
)

st_any_line = st.one_of(
    st_log_line,
    st_noise_line,
    st.text(
        alphabet=st.characters(
            whitelist_categories=("L",),
            blacklist_categories=("Cs",),
        ),
        min_size=1,
        max_size=20,
    ),
)

st_log_file = st.lists(st_any_line, min_size=1, max_size=15)

class TestImplementationsAgree:
    @given(lines=st_log_file)
    @settings(max_examples=500)
    def test_both_implementations_agree(self, lines):
        path = _write_log_file(lines)
        try:
            py_entries = LogParser().load(path)
            rs_entries = RustLogParser().load(path)
            assert _entries_equal(py_entries, rs_entries), (
                f"Mismatch for input:\n{lines}\n"
                f"Python: {[(e.timestamp, e.level, e.fields) for e in py_entries]}\n"
                f"Rust:   {[(e.timestamp, e.level, e.fields) for e in rs_entries]}"
            )
        finally:
            os.unlink(path)

    @given(line=st_log_line)
    @settings(max_examples=500)
    def test_valid_log_lines_agree(self, line):
        path = _write_log_file([line])
        try:
            py_entries = LogParser().load(path)
            rs_entries = RustLogParser().load(path)
            assert _entries_equal(py_entries, rs_entries), (
                f"Mismatch for line: {line!r}\n"
                f"Python: {[(e.timestamp, e.level, e.fields) for e in py_entries]}\n"
                f"Rust:   {[(e.timestamp, e.level, e.fields) for e in rs_entries]}"
            )
        finally:
            os.unlink(path)

let chars: Vec<char> = line.chars().collect();
// ...
let eq_pos = line[i..].find('=');  // byte position!
let key: String = chars[i..eq_pos].iter().collect();  // char position!

fn find_char(chars: &[char], start: usize, target: char) -> Option<usize> {
    for (offset, &ch) in chars[start..].iter().enumerate() {
        if ch == target {
            return Some(start + offset);
        }
    }
    None
}