chore: checkpoint before Python removal

vendor/try-lock/.cargo-checksum.json

@@ -0,0 +1 @@
+{"files":{".cargo_vcs_info.json":"c5f5a5732d2955e7363c9d9151e9683a721a91b9dfb71ac66ada77192468e1f5",".github/workflows/CI.yml":"ad6b0970459dd407dc1311c25fe04e2ef3736bc480ecf9cad3bacd78671af181","Cargo.toml":"b929e378a4dd54a76870264bb0b25d059c8a12ec1dda78a8017d7dbba96260fc","Cargo.toml.orig":"8a54a701aa2af45dbc6621b9e4881638b6f4f7e3a88885fd870a19818a7aacba","LICENSE":"c816a0749cdc6bf062a5111c159723de51b2bfac66a1dac2655abd9e6b1583eb","README.md":"976bf116dd8794213bd242a61f819811a5c5a0fd4372acdbd21308863c05cfb6","src/lib.rs":"4f8e19b938527c5543e3180901a11ec31f8933d5ac918790456d2f4027a12f6f"},"package":"e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"}

vendor/try-lock/.cargo_vcs_info.json

@@ -0,0 +1,6 @@
+{
+  "git": {
+    "sha1": "fd160ecd9105e8afcc43dbea450a0ef6e5128cce"
+  },
+  "path_in_vcs": ""
+}

vendor/try-lock/.github/workflows/CI.yml

@@ -0,0 +1,35 @@
+name: CI
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    name: Test ${{ matrix.rust }}
+    strategy:
+      matrix:
+        rust:
+          - stable
+          - beta
+          - nightly
+          - 1.31.0
+
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v1
+
+      - name: Install Rust (${{ matrix.rust }})
+        uses: actions-rs/toolchain@v1
+        with:
+          profile: minimal
+          toolchain: ${{ matrix.rust }}
+          override: true
+
+      - name: Test
+        uses: actions-rs/cargo@v1
+        with:
+          command: test

vendor/try-lock/Cargo.toml

@@ -0,0 +1,31 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies.
+#
+# If you are reading this file be aware that the original Cargo.toml
+# will likely look very different (and much more reasonable).
+# See Cargo.toml.orig for the original contents.
+
+[package]
+name = "try-lock"
+version = "0.2.5"
+authors = ["Sean McArthur <sean@seanmonstar.com>"]
+description = "A lightweight atomic lock."
+homepage = "https://github.com/seanmonstar/try-lock"
+documentation = "https://docs.rs/try-lock"
+readme = "README.md"
+keywords = [
+    "lock",
+    "atomic",
+]
+categories = [
+    "concurrency",
+    "no-std",
+]
+license = "MIT"
+repository = "https://github.com/seanmonstar/try-lock"
+
+[dependencies]

vendor/try-lock/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2018-2023 Sean McArthur
+Copyright (c) 2016 Alex Crichton
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

vendor/try-lock/README.md

@@ -0,0 +1,44 @@
+# TryLock
+
+- [Crates.io](https://crates.io/crates/try-lock)
+- [Docs](https://docs.rs/try-lock)
+
+A light-weight lock guarded by an atomic boolean.
+
+Most efficient when contention is low, acquiring the lock is a single atomic swap, and releasing it just 1 more atomic swap.
+
+## Example
+
+```rust
+use std::sync::Arc;
+use try_lock::TryLock;
+
+// a thing we want to share
+struct Widget {
+    name: String,
+}
+
+// lock it up!
+let widget1 = Arc::new(TryLock::new(Widget {
+    name: "Spanner".into(),
+}));
+
+let widget2 = widget1.clone();
+
+
+// mutate the widget
+let mut locked = widget1.try_lock().expect("example isn't locked yet");
+locked.name.push_str(" Bundle");
+
+// hands off, buddy
+let not_locked = widget2.try_lock();
+assert!(not_locked.is_none(), "widget1 has the lock");
+
+// ok, you can have it
+drop(locked);
+
+let locked2 = widget2.try_lock().expect("widget1 lock is released");
+
+assert_eq!(locked2.name, "Spanner Bundle");
+```
+

vendor/try-lock/src/lib.rs

@@ -0,0 +1,266 @@
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![deny(warnings)]
+#![cfg_attr(not(test), no_std)]
+
+//! A light-weight lock guarded by an atomic boolean.
+//!
+//! Most efficient when contention is low, acquiring the lock is a single
+//! atomic swap, and releasing it just 1 more atomic swap.
+//!
+//! # Example
+//!
+//! ```
+//! use std::sync::Arc;
+//! use try_lock::TryLock;
+//!
+//! // a thing we want to share
+//! struct Widget {
+//!     name: String,
+//! }
+//!
+//! // lock it up!
+//! let widget1 = Arc::new(TryLock::new(Widget {
+//!     name: "Spanner".into(),
+//! }));
+//!
+//! let widget2 = widget1.clone();
+//!
+//!
+//! // mutate the widget
+//! let mut locked = widget1.try_lock().expect("example isn't locked yet");
+//! locked.name.push_str(" Bundle");
+//!
+//! // hands off, buddy
+//! let not_locked = widget2.try_lock();
+//! assert!(not_locked.is_none(), "widget1 has the lock");
+//!
+//! // ok, you can have it
+//! drop(locked);
+//!
+//! let locked2 = widget2.try_lock().expect("widget1 lock is released");
+//!
+//! assert_eq!(locked2.name, "Spanner Bundle");
+//! ```
+
+#[cfg(test)]
+extern crate core;
+
+use core::cell::UnsafeCell;
+use core::fmt;
+use core::ops::{Deref, DerefMut};
+use core::sync::atomic::{AtomicBool, Ordering};
+use core::marker::PhantomData;
+
+/// A light-weight lock guarded by an atomic boolean.
+///
+/// Most efficient when contention is low, acquiring the lock is a single
+/// atomic swap, and releasing it just 1 more atomic swap.
+///
+/// It is only possible to try to acquire the lock, it is not possible to
+/// wait for the lock to become ready, like with a `Mutex`.
+#[derive(Default)]
+pub struct TryLock<T> {
+    is_locked: AtomicBool,
+    value: UnsafeCell<T>,
+}
+
+impl<T> TryLock<T> {
+    /// Create a `TryLock` around the value.
+    #[inline]
+    pub const fn new(val: T) -> TryLock<T> {
+        TryLock {
+            is_locked: AtomicBool::new(false),
+            value: UnsafeCell::new(val),
+        }
+    }
+
+    /// Try to acquire the lock of this value.
+    ///
+    /// If the lock is already acquired by someone else, this returns
+    /// `None`. You can try to acquire again whenever you want, perhaps
+    /// by spinning a few times, or by using some other means of
+    /// notification.
+    ///
+    /// # Note
+    ///
+    /// The default memory ordering is to use `Acquire` to lock, and `Release`
+    /// to unlock. If different ordering is required, use
+    /// [`try_lock_explicit`](TryLock::try_lock_explicit) or
+    /// [`try_lock_explicit_unchecked`](TryLock::try_lock_explicit_unchecked).
+    #[inline]
+    pub fn try_lock(&self) -> Option<Locked<T>> {
+        unsafe {
+            self.try_lock_explicit_unchecked(Ordering::Acquire, Ordering::Release)
+        }
+    }
+
+    /// Try to acquire the lock of this value using the lock and unlock orderings.
+    ///
+    /// If the lock is already acquired by someone else, this returns
+    /// `None`. You can try to acquire again whenever you want, perhaps
+    /// by spinning a few times, or by using some other means of
+    /// notification.
+    #[inline]
+    #[deprecated(
+        since = "0.2.3",
+        note = "This method is actually unsafe because it unsafely allows \
+        the use of weaker memory ordering. Please use try_lock_explicit instead"
+    )]
+    pub fn try_lock_order(&self, lock_order: Ordering, unlock_order: Ordering) -> Option<Locked<T>> {
+        unsafe {
+            self.try_lock_explicit_unchecked(lock_order, unlock_order)
+        }
+    }
+
+    /// Try to acquire the lock of this value using the specified lock and
+    /// unlock orderings.
+    ///
+    /// If the lock is already acquired by someone else, this returns
+    /// `None`. You can try to acquire again whenever you want, perhaps
+    /// by spinning a few times, or by using some other means of
+    /// notification.
+    ///
+    /// # Panic
+    ///
+    /// This method panics if `lock_order` is not any of `Acquire`, `AcqRel`,
+    /// and `SeqCst`, or `unlock_order` is not any of `Release` and `SeqCst`.
+    #[inline]
+    pub fn try_lock_explicit(&self, lock_order: Ordering, unlock_order: Ordering) -> Option<Locked<T>> {
+        match lock_order {
+            Ordering::Acquire |
+            Ordering::AcqRel |
+            Ordering::SeqCst => {}
+            _ => panic!("lock ordering must be `Acquire`, `AcqRel`, or `SeqCst`"),
+        }
+
+        match unlock_order {
+            Ordering::Release |
+            Ordering::SeqCst => {}
+            _ => panic!("unlock ordering must be `Release` or `SeqCst`"),
+        }
+
+        unsafe {
+            self.try_lock_explicit_unchecked(lock_order, unlock_order)
+        }
+    }
+
+    /// Try to acquire the lock of this value using the specified lock and
+    /// unlock orderings without checking that the specified orderings are
+    /// strong enough to be safe.
+    ///
+    /// If the lock is already acquired by someone else, this returns
+    /// `None`. You can try to acquire again whenever you want, perhaps
+    /// by spinning a few times, or by using some other means of
+    /// notification.
+    ///
+    /// # Safety
+    ///
+    /// Unlike [`try_lock_explicit`], this method is unsafe because it does not
+    /// check that the given memory orderings are strong enough to prevent data
+    /// race.
+    ///
+    /// [`try_lock_explicit`]: Self::try_lock_explicit
+    #[inline]
+    pub unsafe fn try_lock_explicit_unchecked(&self, lock_order: Ordering, unlock_order: Ordering) -> Option<Locked<T>> {
+        if !self.is_locked.swap(true, lock_order) {
+            Some(Locked {
+                lock: self,
+                order: unlock_order,
+                _p: PhantomData,
+            })
+        } else {
+            None
+        }
+    }
+
+    /// Take the value back out of the lock when this is the sole owner.
+    #[inline]
+    pub fn into_inner(self) -> T {
+        debug_assert!(!self.is_locked.load(Ordering::Relaxed), "TryLock was mem::forgotten");
+        self.value.into_inner()
+    }
+}
+
+unsafe impl<T: Send> Send for TryLock<T> {}
+unsafe impl<T: Send> Sync for TryLock<T> {}
+
+impl<T: fmt::Debug> fmt::Debug for TryLock<T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+
+        // Used if the TryLock cannot acquire the lock.
+        struct LockedPlaceholder;
+
+        impl fmt::Debug for LockedPlaceholder {
+            fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+                f.write_str("<locked>")
+            }
+        }
+
+        let mut builder = f.debug_struct("TryLock");
+        if let Some(locked) = self.try_lock() {
+            builder.field("value", &*locked);
+        } else {
+            builder.field("value", &LockedPlaceholder);
+        }
+        builder.finish()
+    }
+}
+
+/// A locked value acquired from a `TryLock`.
+///
+/// The type represents an exclusive view at the underlying value. The lock is
+/// released when this type is dropped.
+///
+/// This type derefs to the underlying value.
+#[must_use = "TryLock will immediately unlock if not used"]
+pub struct Locked<'a, T: 'a> {
+    lock: &'a TryLock<T>,
+    order: Ordering,
+    /// Suppresses Send and Sync autotraits for `struct Locked`.
+    _p: PhantomData<*mut T>,
+}
+
+impl<'a, T> Deref for Locked<'a, T> {
+    type Target = T;
+    #[inline]
+    fn deref(&self) -> &T {
+        unsafe { &*self.lock.value.get() }
+    }
+}
+
+impl<'a, T> DerefMut for Locked<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        unsafe { &mut *self.lock.value.get() }
+    }
+}
+
+impl<'a, T> Drop for Locked<'a, T> {
+    #[inline]
+    fn drop(&mut self) {
+        self.lock.is_locked.store(false, self.order);
+    }
+}
+
+impl<'a, T: fmt::Debug> fmt::Debug for Locked<'a, T> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Debug::fmt(&**self, f)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::TryLock;
+
+    #[test]
+    fn fmt_debug() {
+        let lock = TryLock::new(5);
+        assert_eq!(format!("{:?}", lock), "TryLock { value: 5 }");
+
+        let locked = lock.try_lock().unwrap();
+        assert_eq!(format!("{:?}", locked), "5");
+
+        assert_eq!(format!("{:?}", lock), "TryLock { value: <locked> }");
+    }
+}

vendor/try-lock/target/package/tmp-registry/index/tr/y-/try-lock

@@ -0,0 +1 @@
+{"name":"try-lock","vers":"0.2.5","deps":[],"features":{},"features2":null,"cksum":"19130b8a42ab5b5036c4cd41c0157897c65c32fd20c4c546f1d23e6db3445258","yanked":null,"links":null,"rust_version":null,"v":2}