fn writerow_custom(&self, row: PyObjectRef, vm: &VirtualMachine) -> PyResult {
            let _state = self.state.lock();

            let row: ArgIterable = ArgIterable::try_from_object(vm, row.clone()).map_err(|_e| {
                new_csv_error(
                    vm,
                    format!("'{}' object is not iterable", row.class().name()),
                )
            })?;

            let fields = row.iter(vm)?.collect::<PyResult<Vec<_>>>()?;
            let single_field = fields.len() == 1;
            let mut output = Vec::new();

            for (index, field) in fields.into_iter().enumerate() {
                if index > 0 {
                    output.push(self.dialect.delimiter);
                }

                let stringified;
                let (data, is_str, is_none): (&[u8], bool, bool) = match_class!(match field {
                    ref s @ PyStr => (s.as_bytes(), true, false),
                    crate::builtins::PyNone => (b"", false, true),
                    ref obj => {
                        stringified = obj.str(vm)?;
                        (stringified.as_bytes(), false, false)
                    }
                });

                let (should_quote, error_if_single_empty, use_unquoted) = match self.dialect.quoting {
                    QuoteStyle::Strings => (is_str || field_needs_quotes(data, self.dialect), true, false),
                    QuoteStyle::Notnull => (!is_none, true, false),
                    QuoteStyle::Minimal => (field_needs_quotes(data, self.dialect) || (single_field && data.is_empty()), false, false),
                    QuoteStyle::None => (false, true, true),
                    _ => unreachable!(),
                };

                if should_quote {
                    write_quoted_field(&mut output, data, self.dialect, vm)?;
                } else {
                    if error_if_single_empty && single_field && data.is_empty() {
                        return Err(new_csv_error(
                            vm,
                            "single empty field record must be quoted",
                        ));
                    }
                    if use_unquoted {
                        write_unquoted_field(&mut output, data, self.dialect, vm)?;
                    } else {
                        output.extend_from_slice(data);
                    }
                }
            }

            write_lineterminator(&mut output, self.dialect.lineterminator);

            let s = core::str::from_utf8(&output)
                .map_err(|_| vm.new_unicode_decode_error("csv not utf8"))?;

            self.write.call((s,), vm)
        }