Method get_bytearray_inner

crates/vm/src/bytes_inner.rs:93–136

(self, vm: &VirtualMachine)

    }

    pub fn get_bytearray_inner(self, vm: &VirtualMachine) -> PyResult<PyBytesInner> {
        match (self.source, self.encoding, self.errors) {
            (OptionalArg::Present(obj), OptionalArg::Missing, OptionalArg::Missing) => {
                // Try __index__ first to handle int-like objects that might raise custom exceptions
                if let Some(index_result) = obj.try_index_opt(vm) {
                    match index_result {
                        Ok(index) => Self::get_value_from_size(index, vm),
                        Err(e) => {
                            // Only propagate non-TypeError exceptions
                            // TypeError means the object doesn't support __index__, so fall back
                            if e.fast_isinstance(vm.ctx.exceptions.type_error) {
                                // Fall back to treating as buffer-like object
                                Self::handle_object_fallback(obj, vm)
                            } else {
                                // Propagate other exceptions (e.g., ZeroDivisionError)
                                Err(e)
                            }
                        }
                    }
                } else {
                    Self::handle_object_fallback(obj, vm)
                }
            }
            (OptionalArg::Present(obj), OptionalArg::Present(encoding), errors) => {
                if let Ok(s) = obj.downcast::<PyStr>() {
                    Self::get_value_from_string(s, encoding, errors, vm)
                } else {
                    Err(vm.new_type_error(ENCODING_WITHOUT_STRING.to_owned()))
                }
            }
            (OptionalArg::Missing, OptionalArg::Missing, OptionalArg::Missing) => {
                Ok(PyBytesInner::default())
            }
            (OptionalArg::Missing, OptionalArg::Present(_), _) => {
                Err(vm.new_type_error(ENCODING_WITHOUT_STRING.to_owned()))
            }
            (OptionalArg::Missing, _, OptionalArg::Present(_)) => {
                Err(vm.new_type_error("errors without a string argument"))
            }
            (OptionalArg::Present(_), OptionalArg::Missing, OptionalArg::Present(_)) => {
                Err(vm.new_type_error(STRING_WITHOUT_ENCODING.to_owned()))
            }
        }
    }
}

#[derive(FromArgs)]