Method py_new

crates/stdlib/src/lzma.rs:581–629

(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine)

        type Args = LZMADecompressorConstructorArgs;

        fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {
            if args.format == FORMAT_RAW && args.memlimit.is_some() {
                return Err(vm.new_value_error("Cannot specify memory limit with FORMAT_RAW"));
            }

            if args.format == FORMAT_RAW && args.filters.is_none() {
                return Err(vm.new_value_error("Must specify filters for FORMAT_RAW"));
            }
            if args.format != FORMAT_RAW && args.filters.is_some() {
                return Err(vm.new_value_error("Cannot specify filters except with FORMAT_RAW"));
            }

            let memlimit = args.memlimit.unwrap_or(u64::MAX);
            let decoder_flags = TELL_ANY_CHECK | TELL_NO_CHECK;

            let lzma_stream = match args.format {
                FORMAT_AUTO => {
                    let stream = Stream::new_auto_decoder(memlimit, decoder_flags)
                        .map_err(|e| catch_lzma_error(e, vm))?;
                    LzmaStream::new(stream, CHECK_UNKNOWN, true)
                }
                FORMAT_XZ => {
                    let stream = Stream::new_stream_decoder(memlimit, decoder_flags)
                        .map_err(|e| catch_lzma_error(e, vm))?;
                    LzmaStream::new(stream, CHECK_UNKNOWN, true)
                }
                FORMAT_ALONE => {
                    let stream =
                        Stream::new_lzma_decoder(memlimit).map_err(|e| catch_lzma_error(e, vm))?;
                    LzmaStream::new(stream, CHECK_NONE, false)
                }
                FORMAT_RAW => {
                    let filter_specs = args.filters.unwrap(); // safe: checked above
                    let filters = parse_filter_chain_spec(filter_specs, vm)?;
                    let stream =
                        Stream::new_raw_decoder(&filters).map_err(|e| catch_lzma_error(e, vm))?;
                    LzmaStream::new(stream, CHECK_NONE, false)
                }
                _ => {
                    return Err(
                        vm.new_value_error(format!("Invalid container format: {}", args.format))
                    );
                }
            };

            Ok(Self {
                state: PyMutex::new(DecompressState::new(lzma_stream, vm)),
            })
        }
    }

    #[pyclass(with(Constructor))]