Method acquire

crates/stdlib/src/multiprocessing.rs:131–220

(&self, args: FuncArgs, vm: &VirtualMachine)

        #[pymethod]
        fn acquire(&self, args: FuncArgs, vm: &VirtualMachine) -> PyResult<bool> {
            let blocking: bool = args
                .kwargs
                .get("block")
                .or_else(|| args.args.first())
                .map(|o| o.clone().try_to_bool(vm))
                .transpose()?
                .unwrap_or(true);

            let timeout_obj = args
                .kwargs
                .get("timeout")
                .or_else(|| args.args.get(1))
                .cloned();

            // Calculate timeout in milliseconds
            let full_msecs: u32 = if !blocking {
                0
            } else if timeout_obj.as_ref().is_none_or(|o| vm.is_none(o)) {
                INFINITE
            } else {
                let timeout: f64 = timeout_obj.unwrap().try_float(vm)?.to_f64();
                let timeout = timeout * 1000.0; // convert to ms
                if timeout < 0.0 {
                    0
                } else if timeout >= 0.5 * INFINITE as f64 {
                    return Err(vm.new_overflow_error("timeout is too large"));
                } else {
                    (timeout + 0.5) as u32
                }
            };

            // Check whether we already own the lock
            if self.kind == RECURSIVE_MUTEX && ismine!(self) {
                self.count.fetch_add(1, Ordering::Release);
                return Ok(true);
            }

            // Check whether we can acquire without blocking
            match unsafe { WaitForSingleObjectEx(self.handle.as_raw(), 0, 0) } {
                WAIT_OBJECT_0 => {
                    self.last_tid
                        .store(unsafe { GetCurrentThreadId() }, Ordering::Release);
                    self.count.fetch_add(1, Ordering::Release);
                    return Ok(true);
                }
                WAIT_FAILED => return Err(vm.new_last_os_error()),
                _ => {}
            }

            // Poll with signal checking (CPython uses WaitForMultipleObjectsEx
            // with sigint_event; we poll since RustPython has no sigint event)
            let poll_ms: u32 = 100;
            let mut elapsed: u32 = 0;
            loop {
                let wait_ms = if full_msecs == INFINITE {
                    poll_ms
                } else {