Method py_new

crates/stdlib/src/array.rs:636–697

(
            cls: &Py<PyType>,
            (ArrayNewArgs { spec, init }, kwargs): Self::Args,
            vm: &VirtualMachine,
        )

        type Args = (ArrayNewArgs, KwArgs);

        fn py_new(
            cls: &Py<PyType>,
            (ArrayNewArgs { spec, init }, kwargs): Self::Args,
            vm: &VirtualMachine,
        ) -> PyResult<Self> {
            let spec = spec.as_str().chars().exactly_one().map_err(|_| {
                vm.new_type_error("array() argument 1 must be a unicode character, not str")
            })?;

            if cls.is(Self::class(&vm.ctx)) && !kwargs.is_empty() {
                return Err(vm.new_type_error("array.array() takes no keyword arguments"));
            }

            if spec == 'u' {
                _warnings::warn(
                    vm.ctx.exceptions.deprecation_warning,
                    "The 'u' type code is deprecated and will be removed in Python 3.16".to_owned(),
                    1,
                    vm,
                )?;
            }

            let mut array =
                ArrayContentType::from_char(spec).map_err(|err| vm.new_value_error(err))?;

            if let OptionalArg::Present(init) = init {
                if let Some(init) = init.downcast_ref::<Self>() {
                    match (spec, init.read().typecode()) {
                        (spec, ch) if spec == ch => array.frombytes(&init.get_bytes()),
                        (spec, 'u') => {
                            return Err(vm.new_type_error(format!(
                            "cannot use a unicode array to initialize an array with typecode '{spec}'"
                        )))
                        }
                        _ => {
                            for obj in init.read().iter(vm) {
                                array.push(obj?, vm)?;
                            }
                        }
                    }
                } else if let Some(wtf8) = init.downcast_ref::<PyStr>() {
                    if spec == 'u' {
                        let bytes = Self::_unicode_to_wchar_bytes(wtf8.as_wtf8(), array.itemsize());
                        array.frombytes_move(bytes);
                    } else {
                        return Err(vm.new_type_error(format!(
                            "cannot use a str to initialize an array with typecode '{spec}'"
                        )));
                    }
                } else if init.downcastable::<PyBytes>() || init.downcastable::<PyByteArray>() {
                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
                } else if let Ok(iter) = ArgIterable::try_from_object(vm, init.clone()) {
                    for obj in iter.iter(vm)? {
                        array.push(obj?, vm)?;
                    }
                } else {
                    init.try_bytes_like(vm, |x| array.frombytes(x))?;
                }