Verify each finding against the current code and only fix it if needed.

In `@crates/stdlib/src/csv.rs` at line 20, The import statement brings in an
unused symbol sliceable::SliceableSequenceOp; remove SliceableSequenceOp from
the use line that currently reads use rustpython_vm::{match_class,
sliceable::SliceableSequenceOp}; so it only imports match_class (i.e. change to
import match_class and drop sliceable::SliceableSequenceOp) to eliminate the
unused-import compiler warning.

#!/bin/bash
# Search for .len() calls in the csv.rs file to verify SliceableSequenceOp usage
echo "=== Searching for .len() calls in csv.rs ==="
rg -n '\.len\(\)' crates/stdlib/src/csv.rs

echo ""
echo "=== Looking for context around s.len() specifically ==="
rg -n -C2 's\.len\(\)' crates/stdlib/src/csv.rs

/// Parses the delimiter from a Python object and returns its ASCII value.
///
/// This function attempts to extract the 'delimiter' attribute from the given Python object and ensures that the attribute is a single-character string. If successful, it returns the ASCII value of the character. If the attribute is not a single-character string, an error is returned.
///
/// # Arguments
///
/// * `vm` - A reference to the VirtualMachine, used for executing Python code and manipulating Python objects.
/// * `obj` - The PyObjectRef from which the 'delimiter' attribute is to be parsed.
///
/// # Returns
///
/// If successful, returns a `PyResult<u8>` representing the ASCII value of the 'delimiter' attribute. If unsuccessful, returns a `PyResult` containing an error message.
///
/// # Errors
///
/// This function can return the following errors:
///
/// * If the 'delimiter' attribute is not a single-character string, a type error is returned.
/// * If the 'obj' is not of string type and does not have a 'delimiter' attribute, a type error is returned.
fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<u8> {
    if let Ok(attr) = obj.get_attr("delimiter", vm) {
        parse_delimiter_from_obj(vm, &attr)
    } else {
        match_class!(match obj.to_owned() {
            s @ PyStr => {
                Ok(s.as_str().bytes().exactly_one().map_err(|_| {
                    vm.new_type_error(format!(
                        r#""delimiter" must be a unicode character, not a string of length {}"#,
                        s.len()
                    ))
                })?)
            }
            attr => {
                let msg = format!(
                    r#""delimiter" must be a unicode character, not {}"#,
                    attr.class()
                );
                Err(vm.new_type_error(msg))
            }
        })
    }
}

fn parse_quotechar_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Option<u8>> {
    match_class!(match obj.get_attr("quotechar", vm)? {
        s @ PyStr => {
            Ok(Some(s.as_str().bytes().exactly_one().map_err(|_| {
                vm.new_exception_msg(
                    super::_csv::error(vm),
                    format!(r#""quotechar" must be a unicode character or None, not a string of length {}"#, s.len()),
                )
            })?))
        }
        _n @ PyNone => {
            Ok(None)
        }
        attr => {
            Err(vm.new_exception_msg(
                super::_csv::error(vm),
                format!(
                    r#""quotechar" must be a unicode character or None, not {}"#,
                    attr.class()
                ),
            ))
        }
    })
}

fn prase_lineterminator_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<Terminator> {
    match_class!(match obj.get_attr("lineterminator", vm)? {
        s @ PyStr => {
            Ok(if s.as_bytes().eq(b"\r\n") {
                csv_core::Terminator::CRLF
            } else if let Some(t) = s.as_bytes().first() {
                // Due to limitations in the current implementation within csv_core
                // the support for multiple characters in lineterminator is not complete.
                // only capture the first character
                csv_core::Terminator::Any(*t)
            } else {
                return Err(vm.new_exception_msg(
                    super::_csv::error(vm),
                    r#""lineterminator" must be a string"#.to_owned(),
                ));
            })
        }
        attr => {
            Err(vm.new_type_error(format!(
                r#""lineterminator" must be a string, not {}"#,
                attr.class()
            )))
        }
    })
}

fn prase_quoting_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<QuoteStyle> {
    match_class!(match obj.get_attr("quoting", vm)? {
        i @ PyInt => {
            Ok(i.try_to_primitive::<isize>(vm)?.try_into().map_err(|_e| {
                let msg = r#"bad "quoting" value"#;
                vm.new_type_error(msg.to_owned())
            })?)
        }
        attr => {
            let msg = format!(r#""quoting" must be string or None, not {}"#, attr.class());
            Err(vm.new_type_error(msg.to_owned()))
        }
    })
}

fn prase_dialect_item_from_arg(
    vm: &VirtualMachine,
    obj: PyObjectRef,
) -> Result<DialectItem, ArgumentError> {
    match_class!(match obj {
        s @ PyStr => {
            Ok(DialectItem::Str(s.as_str().to_string()))
        }
        PyNone => {
            Err(ArgumentError::InvalidKeywordArgument("dialect".to_string()))
        }
        t @ PyType => {
            let temp = t
                .as_object()
                .call(vec![], vm)
                .map_err(|_e| ArgumentError::InvalidKeywordArgument("dialect".to_string()))?;
            Ok(DialectItem::Obj(
                PyDialect::try_from_object(vm, temp).map_err(|_| {
                    ArgumentError::InvalidKeywordArgument("dialect".to_string())
                })?,
            ))
        }
        obj => {
            if let Ok(cur_dialect_item) = PyDialect::try_from_object(vm, obj) {
                Ok(DialectItem::Obj(cur_dialect_item))
            } else {
                let msg = "dialect".to_string();
                Err(ArgumentError::InvalidKeywordArgument(msg))
            }
        }
    })
}

impl TryFromObject for PyDialect {
    fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult<Self> {
        let delimiter = parse_delimiter_from_obj(vm, &obj)?;
        let quotechar = parse_quotechar_from_obj(vm, &obj)?;
        let escapechar = parse_escapechar_from_obj(vm, &obj)?;
        let doublequote = obj.get_attr("doublequote", vm)?.try_to_bool(vm)?;
        let skipinitialspace = obj.get_attr("skipinitialspace", vm)?.try_to_bool(vm)?;
        let lineterminator = prase_lineterminator_from_obj(vm, &obj)?;
        let quoting = prase_quoting_from_obj(vm, &obj)?;
        let strict = if let Ok(t) = obj.get_attr("strict", vm) {
            t.try_to_bool(vm).unwrap_or(false)
        } else {
            false
        };

        Ok(Self {
            delimiter,
            quotechar,
            escapechar,
            doublequote,
            skipinitialspace,
            lineterminator,
            quoting,
            strict,
        })
    }
}

fn parse_delimiter_from_obj(vm: &VirtualMachine, obj: &PyObject) -> PyResult<u8> { ... }

Learnt from: ShaharNaveh
Repo: RustPython/RustPython PR: 7181
File: crates/stdlib/src/csv.rs:20-20
Timestamp: 2026-02-17T07:54:36.200Z
Learning: In RustPython's codebase (especially in `**/*.rs`), the `SliceableSequenceOp` trait import from `rustpython_vm::sliceable` is necessary to bring methods like `.len()` into scope for `PyStr`, even if the trait name itself is not directly referenced in the code.

Learnt from: youknowone
Repo: RustPython/RustPython PR: 6110
File: vm/src/frame.rs:1311-1316
Timestamp: 2025-08-26T05:20:54.540Z
Learning: In RustPython's pattern matching implementation, only certain builtin types should have the SEQUENCE flag: list and tuple are confirmed sequences. The user youknowone indicated that bytes, bytearray are not considered sequences in this context, even though they implement sequence-like protocols.

Learnt from: youknowone
Repo: RustPython/RustPython PR: 6110
File: vm/src/frame.rs:1311-1316
Timestamp: 2025-08-26T05:20:54.540Z
Learning: In the RustPython codebase, only certain builtin types should be marked with the SEQUENCE flag for pattern matching. List and tuple are sequences, but bytes, bytearray, and range are not considered sequences in this context, even though they may implement sequence-like protocols.

Learnt from: CR
Repo: RustPython/RustPython PR: 0
File: AGENTS.md:0-0
Timestamp: 2026-02-06T05:30:53.056Z
Learning: Applies to **/*.rs : Use the macro system (`pyclass`, `pymodule`, `pyfunction`, etc.) when implementing Python functionality in Rust

Learnt from: CR
Repo: RustPython/RustPython PR: 0
File: AGENTS.md:0-0
Timestamp: 2026-02-06T00:40:12.400Z
Learning: Applies to **/*.rs : Use the macro system (`pyclass`, `pymodule`, `pyfunction`, etc.) when implementing Python functionality in Rust

Verify each finding against the current code and only fix it if needed.

In `@crates/stdlib/src/csv.rs` around lines 234 - 237, The error message in the
fallback arm for attr currently says `"quoting" must be string or None` but the
code only accepts PyInt (see the PyInt handling above), so update the
constructed message in that match arm (where msg is built and
Err(vm.new_type_error(...)) is returned) to say `"quoting" must be an integer or
None, not {}"`, keeping the existing use of attr.class() to show the offending
type; this ensures the TypeError text matches the PyInt expectation and CPython
style.