Function cformat_bytes

crates/vm/src/cformat.rs:284–377

(
    vm: &VirtualMachine,
    format_string: &[u8],
    values_obj: PyObjectRef,
)

}

pub(crate) fn cformat_bytes(
    vm: &VirtualMachine,
    format_string: &[u8],
    values_obj: PyObjectRef,
) -> PyResult<Vec<u8>> {
    let mut format = CFormatBytes::parse_from_bytes(format_string)
        .map_err(|err| vm.new_value_error(err.to_string()))?;
    let (num_specifiers, mapping_required) = format
        .check_specifiers()
        .ok_or_else(|| specifier_error(vm))?;

    let mut result = vec![];

    let is_mapping = values_obj.class().has_attr(identifier!(vm, __getitem__))
        && !values_obj.fast_isinstance(vm.ctx.types.tuple_type)
        && !values_obj.fast_isinstance(vm.ctx.types.bytes_type)
        && !values_obj.fast_isinstance(vm.ctx.types.bytearray_type);

    if num_specifiers == 0 {
        // literal only
        return if is_mapping
            || values_obj
                .downcast_ref::<tuple::PyTuple>()
                .is_some_and(|e| e.is_empty())
        {
            for (_, part) in format.iter_mut() {
                match part {
                    CFormatPart::Literal(literal) => result.append(literal),
                    CFormatPart::Spec(_) => unreachable!(),
                }
            }
            Ok(result)
        } else {
            Err(vm.new_type_error("not all arguments converted during bytes formatting"))
        };
    }

    if mapping_required {
        // dict
        return if is_mapping {
            for (_, part) in format {
                match part {
                    CFormatPart::Literal(literal) => result.extend(literal),
                    CFormatPart::Spec(CFormatSpecKeyed { mapping_key, spec }) => {
                        let key = mapping_key.unwrap();
                        let value = values_obj.get_item(&key, vm)?;
                        let part_result = spec_format_bytes(vm, &spec, value)?;
                        result.extend(part_result);
                    }
                }
            }
            Ok(result)
        } else {
            Err(vm.new_type_error("format requires a mapping"))
        };
    }

    // tuple