# First, find and read the hashlib.rs file to understand the context
find . -type f -name "hashlib.rs" | head -5

# Get the file and examine lines around 738-745
if [ -f "crates/stdlib/src/hashlib.rs" ]; then
  wc -l "crates/stdlib/src/hashlib.rs"
fi

# Read the relevant section with context
sed -n '700,760p' crates/stdlib/src/hashlib.rs | cat -n

# Search for the function containing this code and understand ArgStrOrBytesLike
rg -n "ArgStrOrBytesLike" crates/stdlib/src/hashlib.rs -B5 -A5 | head -60

# Search for similar error messages or patterns with mixed types in RustPython
rg -n "bytes-like object is required" . --type rust -B5 -A2

# Also check what ArgStrOrBytesLike::Buf actually is
rg -n "enum ArgStrOrBytesLike\|struct.*Buf" . --type rust -A10 | head -40

# Check if there are tests for compare_digest with mixed types
rg -n "compare_digest" . --type python -B3 -A3 | head -80

# Let me check if there are Python test files for compare_digest
find . -type f -name "*.py" | xargs grep -l "compare_digest" 2>/dev/null | head -5

# Look at the definition of ArgStrOrBytesLike to understand what Buf is
fd -e rs | xargs grep -l "ArgStrOrBytesLike" | head -3

# Check the function.rs file to understand ArgStrOrBytesLike definition
if [ -f "vm/src/function.rs" ]; then
  rg -n "enum ArgStrOrBytesLike\|impl.*ArgStrOrBytesLike" vm/src/function.rs -A15 | head -60
elif [ -f "crates/vm/src/function.rs" ]; then
  rg -n "enum ArgStrOrBytesLike\|impl.*ArgStrOrBytesLike" crates/vm/src/function.rs -A15 | head -60
fi

# Search more broadly for ArgStrOrBytesLike definition
rg -n "enum ArgStrOrBytesLike" --type rust -A10

# Also check the test file for compare_digest
if [ -f "Lib/test/test_hmac.py" ]; then
  rg -n "compare_digest" Lib/test/test_hmac.py -B2 -A5
fi

# Check the hashlib tests or docstrings for compare_digest behavior
find . -type f -name "*.py" -exec grep -l "compare_digest" {} \; | xargs grep -l "bytes\|str" | head -3

# Let's check the actual Python test to understand what error CPython produces
grep -n "str.*bytes\|bytes.*str" Lib/test/test_hmac.py -B2 -A2 | head -30

# Let's write a Python script to test CPython's behavior
python3 << 'EOF'
import hmac
import sys

# Test compare_digest with mixed types
test_cases = [
    ("string", b"bytes"),
    (b"bytes", "string"),
]

for a, b in test_cases:
    try:
        result = hmac.compare_digest(a, b)
    except TypeError as e:
        print(f"compare_digest({type(a).__name__}, {type(b).__name__}): {e}")
EOF

# Also check what the current RustPython implementation actually produces
# by looking at how the error case is structured in more detail
sed -n '721,746p' crates/stdlib/src/hashlib.rs | cat -n

# Let me verify the exact behavior by looking at what happens in each case
# The key insight: ArgStrOrBytesLike::Str means string, Buf means bytes-like
# Looking at the match logic:
# Case 1: (Str, Str) -> OK (both strings)
# Case 2: (Buf, Buf) -> OK (both bytes-like)
# Case 3: everything else -> ERROR using b's type

# So if a=Str and b=Buf:
#   - Goes to case 3 (neither case 1 nor case 2 matches)
#   - Error uses b.as_object().class().name() which is bytes
#   - Message: "a bytes-like object is required, not 'bytes'" <- WRONG

# If a=Buf and b=Str:
#   - Goes to case 3
#   - Error uses b.as_object().class().name() which is str
#   - Message: "a bytes-like object is required, not 'str'" <- matches CPython

python3 << 'EOF'
# Verify CPython's behavior more thoroughly
import hmac

test_cases = [
    ("string", b"bytes", "str first"),
    (b"bytes", "string", "bytes first"),
    ("s1", "s2", "both str"),
    (b"b1", b"b2", "both bytes"),
]

for a, b, desc in test_cases:
    try:
        result = hmac.compare_digest(a, b)
        print(f"{desc}: OK - {result}")
    except TypeError as e:
        print(f"{desc}: {e}")
EOF