FreakU
/
emojos
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
emojos/Cargo.lock

2022 lines
50 KiB
Plaintext
Raw Normal View History

Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
[[package]]
name = "adler"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
[[package]]
name = "alloc-no-stdlib"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "2.0.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "alloc-stdlib"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"alloc-no-stdlib",
]
[[package]]
name = "anyhow"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.70"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7de8ce5e0f9f8d88245311066a578d72b7af3e7088f32783804676302df237e4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "askama"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.12.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "47cbc3cf73fa8d9833727bbee4835ba5c421a0d65b72daf9a7b5d0e0f9cfb57e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"askama_derive",
"askama_escape",
]
[[package]]
name = "askama_derive"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.12.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "c22fbe0413545c098358e56966ff22cdd039e10215ae213cfbd65032b119fc94"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"mime",
"mime_guess",
"nom",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"proc-macro2",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"quote",
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "askama_escape"
version = "0.10.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "619743e34b5ba4e9703bba34deac3427c72507c7159f5fd030aea8cac0cfe341"
[[package]]
name = "async-compression"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.3.15"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "942c7cd7ae39e91bde4820d74132e9862e62c2f386c3aa90ccf55949f5bad63a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"brotli",
"flate2",
"futures-core",
"memchr",
"pin-project-lite",
"tokio",
]
[[package]]
name = "async-stream"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "cd56dd203fef61ac097dd65721a419ddccb106b2d2b70ba60a6b529f03961a51"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"async-stream-impl",
"futures-core",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"pin-project-lite",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "async-stream-impl"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "16e62a023e7c117e27523144c5d2459f4397fcc3cab0085af8e2224f643a0193"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "async-trait"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.1.68"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "b9ccdd8f2a161be9bd5c023df56f1b2a0bd1d83872ae53b71a84a12c9bf6e842"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "atomic"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b88d82667eca772c4aa12f0f1348b3ae643424c8876448f3f7bd5787032e234c"
dependencies = [
"autocfg",
]
[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "base64"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.21.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "a4a4ddaa51a5bc52a6948f74c06d20aaaddb71924eab79b8c97a8c556e942d6a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "binascii"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "383d29d513d8764dcdc42ea295d979eb99c3c9f00607b3692cf68a431f7dca72"
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "bitflags"
version = "2.1.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "c70beb79cbb5ce9c4f8e20849978f34225931f665bb49efa6982875a4d5facb3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "brotli"
version = "3.3.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1a0b1dbcc8ae29329621f8d4f0d835787c1c38bb1401979b49d13b0b305ff68"
dependencies = [
"alloc-no-stdlib",
"alloc-stdlib",
"brotli-decompressor",
]
[[package]]
name = "brotli-decompressor"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.3.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4b6561fd3f895a11e8f72af2cb7d22e08366bebc2b6b57f7744c4bda27034744"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"alloc-no-stdlib",
"alloc-stdlib",
]
[[package]]
name = "bumpalo"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "3.12.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "0d261e256854913907f67ed06efbc3338dfe6179796deefc1ff763fc1aee5535"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "byteorder"
version = "1.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610"
[[package]]
name = "bytes"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.4.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "cc"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.79"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "cookie"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.17.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7efb37c3e1ccb1ff97164ad95ac1606e8ccd35b3fa0a7d99a304c7f4a428cc24"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"percent-encoding",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"time",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"version_check",
]
[[package]]
name = "core-foundation"
version = "0.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "core-foundation-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.8.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "crc32fast"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
dependencies = [
"cfg-if",
]
[[package]]
name = "crossbeam-utils"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.8.15"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3c063cd8cc95f5c377ed0d4b49a4b21f632396ff690e8470c29b3359b346984b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
]
[[package]]
name = "devise"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d6eacefd3f541c66fc61433d65e54e0e46e0a029a819a7dbbc7a7b489e8a85f8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"devise_codegen",
"devise_core",
]
[[package]]
name = "devise_codegen"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9c8cf4b8dd484ede80fd5c547592c46c3745a617c8af278e2b72bea86b2dfed6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"devise_core",
"quote",
]
[[package]]
name = "devise_core"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "35b50dba0afdca80b187392b24f2499a88c336d5a8493e4b4ccfb608708be56a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"bitflags 2.1.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"proc-macro2",
"proc-macro2-diagnostics",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "either"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.8.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "emojos-dot-in"
version = "2.0.0"
dependencies = [
"anyhow",
"askama",
"reqwest",
"rocket",
"serde",
"tokio",
"zip",
]
[[package]]
name = "encoding_rs"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.8.32"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "071a31f4ee85403370b58aca746f01041ede6f0da2730960ad001edc2b71b394"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "errno"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50d6a0976c999d473fe89ad888d5a284e55366d9dc9038b1ba2aa15128c4afa0"
dependencies = [
"errno-dragonfly",
"libc",
"windows-sys 0.45.0",
]
[[package]]
name = "errno-dragonfly"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
dependencies = [
"cc",
"libc",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "fastrand"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.9.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "e51093e27b0797c359783294ca4f0a911c270184cb10f85783b118614a1501be"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"instant",
]
[[package]]
name = "figment"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.10.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "4e56602b469b2201400dec66a66aec5a9b8761ee97cd1b8c96ab2483fcc16cc9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"atomic",
"pear",
"serde",
"toml",
"uncased",
"version_check",
]
[[package]]
name = "flate2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.0.25"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"crc32fast",
"miniz_oxide",
]
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
"foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "form_urlencoded"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.1.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"percent-encoding",
]
[[package]]
name = "futures"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "futures-io"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "futures-sink"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "futures-task"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "futures-util"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
[[package]]
name = "generator"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.7.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "33a20a288a94683f5f4da0adecdbe095c94a77c295e514cc6484e9394dd8376e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cc",
"libc",
"log",
"rustversion",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"windows",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "getrandom"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "c05aeb6a22b8f62540c194aac980f2115af067bfe15a0734d7277a768d396b31"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"libc",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"wasi",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "glob"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "h2"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "5be7b54589b581f624f566bf5d8eb2bab1db736c51528720b6bd36b96b55924d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bytes",
"fnv",
"futures-core",
"futures-sink",
"futures-util",
"http",
"indexmap",
"slab",
"tokio",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"tokio-util",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"tracing",
]
[[package]]
name = "hashbrown"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.12.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "hermit-abi"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "ee512640fe35acbfb4bb779db6f0d80704c2cacfa2e39b601ef3e3f47d1ae4c7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"libc",
]
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "hermit-abi"
version = "0.3.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "fed44880c466736ef9a5c5b5facefb5ed0785676d0c02d612db14e54f0d84286"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "http"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "http-body"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
dependencies = [
"bytes",
"http",
"pin-project-lite",
]
[[package]]
name = "httparse"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.8.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "httpdate"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c4a1e36c821dbe04574f602848a19f742f4fb3c98d40449f11bcad18d6b17421"
[[package]]
name = "hyper"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.14.25"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "cc5e554ff619822309ffd57d8734d77cd5ce6238bc956f037ea06c58238c9899"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bytes",
"futures-channel",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"httparse",
"httpdate",
"itoa",
"pin-project-lite",
"socket2",
"tokio",
"tower-service",
"tracing",
"want",
]
[[package]]
name = "hyper-tls"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
dependencies = [
"bytes",
"hyper",
"native-tls",
"tokio",
"tokio-native-tls",
]
[[package]]
name = "idna"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.3.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"unicode-bidi",
"unicode-normalization",
]
[[package]]
name = "indexmap"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.9.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"autocfg",
"hashbrown",
"serde",
]
[[package]]
name = "inlinable_string"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
[[package]]
name = "instant"
version = "0.1.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c"
dependencies = [
"cfg-if",
]
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "io-lifetimes"
version = "1.0.10"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9c66c74d2ae7e79a5a8f7ac924adbe38ee42a859c6539ad869eb51f0b52dc220"
dependencies = [
"hermit-abi 0.3.1",
"libc",
"windows-sys 0.48.0",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "ipnet"
version = "2.7.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "12b6ee2129af8d4fb011108c73d99a1b83a85977f23b82460c0ae2e25bb4b57f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "is-terminal"
version = "0.4.6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "256017f749ab3117e93acb91063009e1f1bb56d03965b14c2c8df4eb02c524d8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"hermit-abi 0.3.1",
"io-lifetimes",
"rustix",
"windows-sys 0.45.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "itoa"
version = "1.0.6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "js-sys"
version = "0.3.61"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "445dde2150c55e483f3d8416706b97ec8e8237c307e5b7b4b8dd15e6af2a0730"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"wasm-bindgen",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "libc"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.141"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3304a64d199bb964be99741b7a14d26972741915b3649639149b2479bb46f4b5"
[[package]]
name = "linux-raw-sys"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d59d8c75012853d2e872fb56bc8a2e53718e2cafe1a4c823143141c6d90c322f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "lock_api"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.4.9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "435011366fe56583b16cf956f9df0095b405b82d76425bc8981c0e22e60ec4df"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"autocfg",
"scopeguard",
]
[[package]]
name = "log"
version = "0.4.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "abb12e687cfb44aa40f41fc3978ef76448f9b6038cad6aef4259d3c095a2382e"
dependencies = [
"cfg-if",
]
[[package]]
name = "loom"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff50ecb28bb86013e935fb6683ab1f6d3a20016f123c76fd4c27470076ac30f5"
dependencies = [
"cfg-if",
"generator",
"scoped-tls",
"serde",
"serde_json",
"tracing",
"tracing-subscriber",
]
[[package]]
name = "matchers"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
dependencies = [
"regex-automata",
]
[[package]]
name = "memchr"
version = "2.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
[[package]]
name = "mime"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.17"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "mime_guess"
version = "2.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
dependencies = [
"mime",
"unicase",
]
[[package]]
name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.6.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"adler",
]
[[package]]
name = "mio"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.8.6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "5b9d9a46eff5b4ff64b45a9e316a6d1e0bc719ef429cbec4dc630684212bfdf9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"libc",
"log",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"wasi",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-sys 0.45.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "multer"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.1.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "01acbdc23469fd8fe07ab135923371d5f5a422fbf9c522158677c8eb15bc51c2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bytes",
"encoding_rs",
"futures-util",
"http",
"httparse",
"log",
"memchr",
"mime",
"spin",
"tokio",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"tokio-util",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"version_check",
]
[[package]]
name = "native-tls"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.11"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"lazy_static",
"libc",
"log",
"openssl",
"openssl-probe",
"openssl-sys",
"schannel",
"security-framework",
"security-framework-sys",
"tempfile",
]
[[package]]
name = "nom"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "7.1.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"memchr",
"minimal-lexical",
]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "nu-ansi-term"
version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
dependencies = [
"overload",
"winapi",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "num_cpus"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.15.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "0fac9e2da13b5eb447a6ce3d392f23a29d8694bff781bf03a16cd9ac8697593b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"hermit-abi 0.2.6",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"libc",
]
[[package]]
name = "once_cell"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.17.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "b7e5500299e16ebb147ae15a00a942af264cf3688f47923b8fc2cd5858f23ad3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "openssl"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.10.49"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4d2f106ab837a24e03672c59b1239669a0596406ff657c3c0835b6b7f0f35a33"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"bitflags 1.3.2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"cfg-if",
"foreign-types",
"libc",
"once_cell",
"openssl-macros",
"openssl-sys",
]
[[package]]
name = "openssl-macros"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.1.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "openssl-probe"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
[[package]]
name = "openssl-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.9.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3a20eace9dc2d82904039cb76dcf50fb1a0bba071cfd1629720b5d6f1ddba0fa"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cc",
"libc",
"pkg-config",
"vcpkg",
]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "overload"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b15813163c1d831bf4a13c3610c05c0d03b39feb07f7e09fa234dac9b15aaf39"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "parking_lot"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
dependencies = [
"lock_api",
"parking_lot_core",
]
[[package]]
name = "parking_lot_core"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.9.7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9069cbb9f99e3a5083476ccb29ceb1de18b9118cafa53e90c9551235de2b9521"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"libc",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"redox_syscall 0.2.16",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"smallvec",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-sys 0.45.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "pear"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "0ec95680a7087503575284e5063e14b694b7a9c0b065e5dceec661e0497127e8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"inlinable_string",
"pear_codegen",
"yansi",
]
[[package]]
name = "pear_codegen"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9661a3a53f93f09f2ea882018e4d7c88f6ff2956d809a276060476fd8c879d3c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"proc-macro2-diagnostics",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "percent-encoding"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "2.2.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "pin-project-lite"
version = "0.2.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e0a7ae3ac2f1173085d398531c705756c94a4c56843785df85a60c1a0afac116"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.3.26"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "ppv-lite86"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.17"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "proc-macro2"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.56"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "2b63bdb0cd06f1f4dedf69b254734f9b45af66e4a031e42a7480257d9898b435"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"unicode-ident",
]
[[package]]
name = "proc-macro2-diagnostics"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.10.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "606c4ba35817e2922a308af55ad51bab3645b59eae5c570d4a6cf07e36bd493b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"version_check",
"yansi",
]
[[package]]
name = "quote"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.26"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4424af4bf778aae2051a77b60283332f386554255d722233d09fbfc7e30da2fc"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
]
[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.6.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"getrandom",
]
[[package]]
name = "redox_syscall"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "fb5a58c1855b4b6819d59012155603f0b22ad30cad752600aadfcb695265519a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"bitflags 1.3.2",
]
[[package]]
name = "redox_syscall"
version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
dependencies = [
"bitflags 1.3.2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "ref-cast"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f43faa91b1c8b36841ee70e97188a869d37ae21759da6846d4be66de5bf7b12c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"ref-cast-impl",
]
[[package]]
name = "ref-cast-impl"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "8d2275aab483050ab2a7364c1a46604865ee7d6906684e08db0f090acf74f9e7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "regex"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.7.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "8b1f693b24f6ac912f4893ef08244d70b6067480d2f1a46e950c9691e6749d1d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"regex-syntax",
]
[[package]]
name = "regex-automata"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
dependencies = [
"regex-syntax",
]
[[package]]
name = "regex-syntax"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.6.29"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "reqwest"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.11.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "27b71749df584b7f4cac2c426c127a7c785a5106cc98f7a8feb044115f0fa254"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"async-compression",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"base64",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"bytes",
"encoding_rs",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"hyper",
"hyper-tls",
"ipnet",
"js-sys",
"log",
"mime",
"native-tls",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"once_cell",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"percent-encoding",
"pin-project-lite",
"serde",
"serde_json",
"serde_urlencoded",
"tokio",
"tokio-native-tls",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"tokio-util",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"tower-service",
"url",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"winreg",
]
[[package]]
name = "rocket"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.5.0-rc.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "58734f7401ae5cfd129685b48f61182331745b357b96f2367f01aebaf1cc9cc9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"async-stream",
"async-trait",
"atomic",
"binascii",
"bytes",
"either",
"figment",
"futures",
"indexmap",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"is-terminal",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"log",
"memchr",
"multer",
"num_cpus",
"parking_lot",
"pin-project-lite",
"rand",
"ref-cast",
"rocket_codegen",
"rocket_http",
"serde",
"state",
"tempfile",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"time",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"tokio",
"tokio-stream",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"tokio-util",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"ubyte",
"version_check",
"yansi",
]
[[package]]
name = "rocket_codegen"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.5.0-rc.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7093353f14228c744982e409259fb54878ba9563d08214f2d880d59ff2fc508b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"devise",
"glob",
"indexmap",
"proc-macro2",
"quote",
"rocket_http",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"unicode-xid",
]
[[package]]
name = "rocket_http"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.5.0-rc.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "936012c99162a03a67f37f9836d5f938f662e26f2717809761a9ac46432090f4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cookie",
"either",
"futures",
"http",
"hyper",
"indexmap",
"log",
"memchr",
"pear",
"percent-encoding",
"pin-project-lite",
"ref-cast",
"serde",
"smallvec",
"stable-pattern",
"state",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"time",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"tokio",
"uncased",
]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "rustix"
version = "0.37.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2aae838e49b3d63e9274e1c01833cc8139d3fec468c3b84688c628f44b1ae11d"
dependencies = [
"bitflags 1.3.2",
"errno",
"io-lifetimes",
"libc",
"linux-raw-sys",
"windows-sys 0.45.0",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "rustversion"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.12"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4f3208ce4d8448b3f3e7d168a73f5e0c43a61e32930de3bceeccedb388b6bf06"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "ryu"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.13"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "schannel"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.1.21"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "713cfb06c7059f3588fb8044c0fad1d09e3c01d225e25b9220dbfdcf16dbb1b3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-sys 0.42.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "scoped-tls"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.0.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "e1cf6437eb19a8f4a6cc0f7dca544973b0b78843adbfeb3683d1a94a0024a294"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "scopeguard"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
[[package]]
name = "security-framework"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.8.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "a332be01508d814fed64bf28f798a146d73792121129962fdf335bb3c49a4254"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"bitflags 1.3.2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"core-foundation",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.8.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "31c9bb296072e961fcbd8853511dd39c2d8be2deb1e17c6860b1d30732b323b4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "serde"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.159"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3c04e8343c3daeec41f58990b9d77068df31209f2af111e059e9fe9646693065"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"serde_derive",
]
[[package]]
name = "serde_derive"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.159"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4c614d17805b093df4b147b51339e7e44bf05ef59fba1e45d83500bcfb4d8585"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "serde_json"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.95"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d721eca97ac802aa7777b701877c8004d950fc142651367300d21c1cc0194744"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"itoa",
"ryu",
"serde",
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
dependencies = [
"form_urlencoded",
"itoa",
"ryu",
"serde",
]
[[package]]
name = "sharded-slab"
version = "0.1.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31"
dependencies = [
"lazy_static",
]
[[package]]
name = "signal-hook-registry"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.4.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"libc",
]
[[package]]
name = "slab"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "6528351c9bc8ab22353f9d776db39a20288e8d6c37ef8cfe3317cf875eecfc2d"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
"autocfg",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "smallvec"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "1.10.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "a507befe795404456341dfab10cef66ead4c041f62b8b11bbb92bffe5d0953e0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "socket2"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"libc",
"winapi",
]
[[package]]
name = "spin"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.9.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "stable-pattern"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4564168c00635f88eaed410d5efa8131afa8d8699a612c80c455a0ba05c21045"
dependencies = [
"memchr",
]
[[package]]
name = "state"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dbe866e1e51e8260c9eed836a042a5e7f6726bb2b411dffeaa712e19c388f23b"
dependencies = [
"loom",
]
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "syn"
version = "1.0.109"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "syn"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.0.13"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4c9da457c5285ac1f936ebd076af6dac17a61cfe7826f2076b4d015cf47bc8ec"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "tempfile"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "3.5.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "b9fbec84f381d5795b08656e4912bec604d162bff9291d6189a78f4c8ab87998"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"fastrand",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"redox_syscall 0.3.5",
"rustix",
"windows-sys 0.45.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "thread_local"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.1.7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"cfg-if",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"once_cell",
]
[[package]]
name = "time"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.20"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "cd0cbfecb4d19b5ea75bb31ad904eb5b9fa13f21079c3b92017ebdf4999a5890"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"itoa",
"serde",
"time-core",
"time-macros",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
name = "time-core"
version = "0.1.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "2e153e1f1acaef8acc537e68b44906d2db6436e2b35ac2c6b42640fff91f00fd"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "time-macros"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "fd80a657e71da814b8e5d60d3374fc6d35045062245d80224748ae522dd76f36"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
"time-core",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "tinyvec"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
dependencies = [
"tinyvec_macros",
]
[[package]]
name = "tinyvec_macros"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.1.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "tokio"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.27.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "d0de47a4eecbe11f498978a9b29d792f0d2692d1dd003650c24c76510e3bc001"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"autocfg",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"bytes",
"libc",
"mio",
"num_cpus",
"pin-project-lite",
"signal-hook-registry",
"socket2",
"tokio-macros",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-sys 0.45.0",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "tokio-macros"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "2.0.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "61a573bdc87985e9d6ddeed1b3d864e8a302c847e40d647746df2f1de209d1ce"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 2.0.13",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "tokio-native-tls"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"native-tls",
"tokio",
]
[[package]]
name = "tokio-stream"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.1.12"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "8fb52b74f05dbf495a8fba459fdc331812b96aa086d9eb78101fa0d4569c3313"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"futures-core",
"pin-project-lite",
"tokio",
]
[[package]]
name = "tokio-util"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.7.7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bytes",
"futures-core",
"futures-sink",
"pin-project-lite",
"tokio",
"tracing",
]
[[package]]
name = "toml"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.5.11"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"serde",
]
[[package]]
name = "tower-service"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
[[package]]
name = "tracing"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.1.37"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.1.23"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 1.0.109",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
[[package]]
name = "tracing-core"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.1.30"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "24eb03ba0eab1fd845050058ce5e616558e8f8d8fca633e6b163fe25c797213a"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"once_cell",
"valuable",
]
[[package]]
name = "tracing-log"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "78ddad33d2d10b1ed7eb9d1f518a5674713876e97e5bb9b7345a7984fbb4f922"
dependencies = [
"lazy_static",
"log",
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.3.16"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "a6176eae26dd70d0c919749377897b54a9276bd7061339665dd68777926b5a70"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"matchers",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"nu-ansi-term",
"once_cell",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"regex",
"sharded-slab",
"smallvec",
"thread_local",
"tracing",
"tracing-core",
"tracing-log",
]
[[package]]
name = "try-lock"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "ubyte"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.10.3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "c81f0dae7d286ad0d9366d7679a77934cfc3cf3a8d67e82669794412b2368fe6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"serde",
]
[[package]]
name = "uncased"
version = "0.9.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09b01702b0fd0b3fadcf98e098780badda8742d4f4a7676615cad90e8ac73622"
dependencies = [
"serde",
"version_check",
]
[[package]]
name = "unicase"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50f37be617794602aabbeee0be4f259dc1778fabe05e2d67ee8f79326d5cb4f6"
dependencies = [
"version_check",
]
[[package]]
name = "unicode-bidi"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.13"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "unicode-ident"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "1.0.8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "e5464a87b239f13a63a501f2701565754bae92d243d4bb7eb12f6d57d2269bf4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "unicode-normalization"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.1.22"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"tinyvec",
]
[[package]]
name = "unicode-xid"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "0.2.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "url"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
version = "2.3.1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"form_urlencoded",
"idna",
"percent-encoding",
]
[[package]]
name = "valuable"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d"
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
[[package]]
name = "want"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ce8a968cb1cd110d136ff8b819a556d6fb6d919363c61534f6860c7eb172ba0"
dependencies = [
"log",
"try-lock",
]
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "31f8dcbc21f30d9b8f2ea926ecb58f6b91192c17e9d33594b3df58b2007ca53b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "95ce90fd5bcc06af55a641a86428ee4229e44e07033963a2290a8e241607ccb9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"bumpalo",
"log",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"once_cell",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 1.0.109",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.4.34"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "f219e0d211ba40266969f6dbdd90636da12f75bee4fc9d6c23d1260dadb51454"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"cfg-if",
"js-sys",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4c21f77c0bedc37fd5dc21f897894a5ca01e7bb159884559461862ae90c0b4c5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "2aff81306fcac3c7515ad4e177f521b5c9a15f2b08f4e32d823066102f35a5f6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"proc-macro2",
"quote",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"syn 1.0.109",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.2.84"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "0046fef7e28c3804e5e38bfa31ea2a0f73905319b677e57ebe37e49358989b5d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "web-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.3.61"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "e33b99f4b23ba3eec1a53ac264e35a755f00e966e0065077d6027c0f575b0b97"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
"winapi-i686-pc-windows-gnu",
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.44.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9e745dab35a0c4c77aa3ce42d595e13d2003d6902d6b08c9ef5fc326d08da12b"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-targets 0.42.2",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "windows-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.42.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "5a3e1820f08b8513f676f7ab6c1f99ff312fb97b553d30ff4dd86f9f15728aa7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows_aarch64_gnullvm 0.42.2",
"windows_aarch64_msvc 0.42.2",
"windows_i686_gnu 0.42.2",
"windows_i686_msvc 0.42.2",
"windows_x86_64_gnu 0.42.2",
"windows_x86_64_gnullvm 0.42.2",
"windows_x86_64_msvc 0.42.2",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
]
[[package]]
name = "windows-sys"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.45.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "75283be5efb2831d37ea142365f009c02ec203cd29a3ebecbc093d52315b66d0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"windows-targets 0.42.2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows-sys"
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
dependencies = [
"windows-targets 0.48.0",
]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows-targets"
version = "0.42.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "8e5180c00cd44c9b1c88adb3693291f1cd93605ded80c250a75d472756b4d071"
dependencies = [
"windows_aarch64_gnullvm 0.42.2",
"windows_aarch64_msvc 0.42.2",
"windows_i686_gnu 0.42.2",
"windows_i686_msvc 0.42.2",
"windows_x86_64_gnu 0.42.2",
"windows_x86_64_gnullvm 0.42.2",
"windows_x86_64_msvc 0.42.2",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows-targets"
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7b1eb6f0cd7c80c79759c929114ef071b87354ce476d9d94271031c0497adfd5"
dependencies = [
"windows_aarch64_gnullvm 0.48.0",
"windows_aarch64_msvc 0.48.0",
"windows_i686_gnu 0.48.0",
"windows_i686_msvc 0.48.0",
"windows_x86_64_gnu 0.48.0",
"windows_x86_64_gnullvm 0.48.0",
"windows_x86_64_msvc 0.48.0",
]
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_aarch64_gnullvm"
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "597a5118570b68bc08d8d59125332c54f1ba9d9adeedeef5b99b02ba2b0698f8"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_aarch64_gnullvm"
version = "0.48.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_aarch64_msvc"
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "e08e8864a60f06ef0d0ff4ba04124db8b0fb3be5776a5cd47641e942e58c4d43"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_aarch64_msvc"
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_i686_gnu"
version = "0.42.2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "c61d927d8da41da96a81f029489353e68739737d3beca43145c8afec9a31a84f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_i686_gnu"
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_i686_msvc"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "44d840b6ec649f480a41c8d80f9c65108b92d89345dd94027bfe06ac444d1060"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_i686_msvc"
version = "0.48.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_gnu"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "8de912b8b8feb55c064867cf047dda097f92d51efad5b491dfb98f6bbb70cb36"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_gnu"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_gnullvm"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "26d41b46a36d453748aedef1486d5c7a85db22e56aff34643984ea85514e94a3"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "windows_x86_64_gnullvm"
version = "0.48.0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_msvc"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.42.2"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "9aec5da331524158c6d1a4ac0ab1541149c0b9505fde06423b02f5ef0106b9f0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_msvc"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.48.0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
[[package]]
name = "winreg"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
dependencies = [
"winapi",
]
[[package]]
name = "yansi"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec"
[[package]]
name = "zip"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
version = "0.6.4"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
checksum = "0445d0fbc924bb93539b4316c11afb121ea39296f99a3c4c9edad09e3658cdef"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
dependencies = [
"byteorder",
"crc32fast",
"crossbeam-utils",
"flate2",
]