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

2272 lines
56 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
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "addr2line"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.21.0"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"gimli",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "adler"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "aho-corasick"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.1.3"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"memchr",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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-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 = "askama"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08: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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "b79091df18a97caea757e28cd2d5fda49c6cd4bd01ddffd7ff01ace0c0ad2c28"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.12.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "19fe8d6cb13c4714962c072ea496f3392015f0989b1a2847bb4b2d9effd71d83"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"askama_parser",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"mime",
"mime_guess",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
[[package]]
name = "askama_parser"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.1"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "acb1161c6b64d1c3d83108213c2a2533a342ac225aabd0bda218278c2ddb00c0"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
dependencies = [
"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
[[package]]
name = "async-compression"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "07dbbf24db18d609b1462965249abdf49129ccad073ec257da372adc83259c60"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.1.80"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "c6fa2087f2753a7da8cc1c0dbfcf89579dd57458e36769de5ac750b4671737ca"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-05-21 13:56:52 -07:00
version = "0.5.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
2023-05-21 13:56:52 -07:00
checksum = "c59bdb34bc650a32731b31bd8f0829cc15d24a708ee31559e0bb34f2bc320cba"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
[[package]]
name = "atomic"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8d818003e740b63afc82337e3160717f4f63078720a810b7b903e70a5d1d2994"
dependencies = [
"bytemuck",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "autocfg"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.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
2024-04-20 09:17:37 -07:00
checksum = "f1fdabc7756949593fe60f30ec81974b613357de856987752631dea1e3394c80"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
[[package]]
name = "backtrace"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.71"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "26b05800d2e817c8b3b4b54abd461726265fa9789ae34330622f2db9ee696f9d"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"addr2line",
"cc",
"cfg-if",
"libc",
"miniz_oxide",
"object",
"rustc-demangle",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "base64"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.22.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
2024-04-20 09:17:37 -07:00
checksum = "9475866fec1451be56a3c2400fd081ff546538961565ccb5b7142cbd22bc7a51"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "cf4b9d6a944f767f8e5e0db018570623c85f3d925ac718db4e06d0187adb21c1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "4.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "125740193d7fee5cc63ab9e16c2fdc4e07c74ba755cc53b327d6ea029e9fc569"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
"brotli-decompressor",
]
[[package]]
name = "brotli-decompressor"
cargo update
2024-04-20 09:17:37 -07:00
version = "3.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "65622a320492e09b5e0ac436b14c54ff68199bac392d0e89a6832c4518eea525"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "3.16.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
2024-04-20 09:17:37 -07:00
checksum = "79296716171880943b8470b5f8d03aa55eb2e645a4874bdbb28adb49162e012c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
[[package]]
name = "bytemuck"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.15.0"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "5d6d68c57235a3a081186990eca2867354726650f42f7516ca50c28d6281fd15"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -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 = "byteorder"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "1.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "bytes"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.6.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
2024-04-20 09:17:37 -07:00
checksum = "514de17de45fdb8dc022b1a7975556c53c86f9f0aa5f534b98977b171857c2c9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "d32a725bc159af97c3e629873bb9f88fb8cf8a4867175f76dc987815ea07c83b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.18.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
2024-04-20 09:17:37 -07:00
checksum = "4ddef33a339a91ea89fb53151bd0a4689cfce27055c291dfa69945475d22c747"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.9.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
2024-04-20 09:17:37 -07:00
checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "core-foundation-sys"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "b3855a8a784b474f333699ef2bbca9db2c4a1f6d9088a90a2d25b1eb53111eaa"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "crossbeam-utils"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.8.19"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "248e3bacc7dc6baa3b21e405ee045c3047101a49145e7e9eca583ab4c2ca5345"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-09-24 10:49:58 -07:00
[[package]]
name = "deranged"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.11"
cargo update
2023-09-24 10:49:58 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
dependencies = [
"powerfmt",
]
cargo update
2023-09-24 10:49:58 -07: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 = "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 = [
cargo update
2024-04-20 09:17:37 -07:00
"bitflags 2.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
"proc-macro2",
"proc-macro2-diagnostics",
"quote",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.11.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
2024-04-20 09:17:37 -07:00
checksum = "a47c1c47d2f5964e29c61246e81db715514cd532db6b5116a25ea3c03d6780a2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = [
"askama",
"reqwest",
"rocket",
"serde",
"tokio",
"zip",
]
[[package]]
name = "encoding_rs"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.8.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "b45de904aa0b010bce2ab45264d0631681847fa7b6f2eaa7dab7619943bc4f59"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "equivalent"
cargo update
2023-09-24 10:49:58 -07:00
version = "1.0.1"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
cargo update
2023-07-06 23:45:16 -07:00
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "errno"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.8"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
dependencies = [
"libc",
cargo update
2024-04-20 09:17:37 -07:00
"windows-sys 0.52.0",
remove lambda support; update deps
2023-04-05 20:58:21 -07: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 = "fastrand"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.0.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
2024-04-20 09:17:37 -07:00
checksum = "658bd65b1cf4c852a3cc96f18a8ce7b5640f6b703f905c7d74532294c2a63984"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "figment"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.10.18"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "d032832d74006f99547004d49410a4b4218e4c33382d56ca3ff89df74f86b953"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"atomic 0.6.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
"pear",
"serde",
"toml",
"uncased",
"version_check",
]
[[package]]
name = "flate2"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "1.0.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
version = "1.2.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
2024-04-20 09:17:37 -07:00
checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.30"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-07-06 23:45:16 -07:00
version = "0.7.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"
cargo update
2023-07-06 23:45:16 -07:00
checksum = "5cc16584ff22b460a382b7feec54b23d2908d858152e5739a120b949293bd74e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
version = "0.2.14"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "94b22e06ecb0110981051723910cbf0b5f5e09a2062dd7663334ee79a9d1286c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "gimli"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.28.1"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
cargo update
2023-07-06 23:45:16 -07: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 = "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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.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
2024-04-20 09:17:37 -07:00
checksum = "816ec7294445779408f36fe57bc5b7fc1cf59664059096c65f905c1c61f58069"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"http 1.1.0",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"indexmap",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"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
2024-04-20 09:17:37 -07:00
version = "0.14.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
2024-04-20 09:17:37 -07:00
checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "hermit-abi"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "d231dfb89cfffdbc30e7fc41579ed6066ad03abda9e567ccafae602b97ec5024"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "http"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "21b9ddb458710bc376481b842f5da65cdf31522de232c1ca8146abce2a358258"
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "http-body"
version = "0.4.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
dependencies = [
"bytes",
"http 0.2.12",
"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 = "http-body"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1cac85db508abc24a2e48553ba12a996e87244a0395ce011e62b37158745d643"
dependencies = [
"bytes",
"http 1.1.0",
]
[[package]]
name = "http-body-util"
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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "0475f8b2ac86659c21b64320d5d653f9efe42acd2a4e560073ec61a155a34f1d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"futures-core",
"http 1.1.0",
"http-body 1.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
"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"
cargo update
2023-09-24 10:49:58 -07:00
version = "1.0.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
2023-09-24 10:49:58 -07:00
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "hyper"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.14.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"http 0.2.12",
"http-body 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
"httparse",
"httpdate",
"itoa",
"pin-project-lite",
cargo update
2024-04-20 09:17:37 -07:00
"socket2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
"tower-service",
"tracing",
"want",
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "hyper"
version = "1.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fe575dd17d0862a9a33781c8c4696a55c320909004a67a00fb286ba8b1bc496d"
dependencies = [
"bytes",
"futures-channel",
"futures-util",
"h2",
"http 1.1.0",
"http-body 1.0.0",
"httparse",
"itoa",
"pin-project-lite",
"smallvec",
"tokio",
"want",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "hyper-tls"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.6.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
2024-04-20 09:17:37 -07:00
checksum = "70206fc6890eaca9fde8a0bf71caa2ddfc9fe045ac9e5c70df101a7dbde866e0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"http-body-util",
"hyper 1.3.1",
"hyper-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
"native-tls",
"tokio",
"tokio-native-tls",
cargo update
2024-04-20 09:17:37 -07:00
"tower-service",
]
[[package]]
name = "hyper-util"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ca38ef113da30126bbff9cd1705f9273e15d45498615d138b0c20279ac7a76aa"
dependencies = [
"bytes",
"futures-channel",
"futures-util",
"http 1.1.0",
"http-body 1.0.0",
"hyper 1.3.1",
"pin-project-lite",
"socket2",
"tokio",
"tower",
"tower-service",
"tracing",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "idna"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.2.6"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"equivalent",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"hashbrown",
"serde",
cargo update
2023-07-06 23:45:16 -07: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 = "inlinable_string"
version = "0.1.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c8fae54786f62fb2918dcfae3d568594e50eb9b5c25bf04371af6fe7516452fb"
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "ipnet"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "2.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "f23ff5ef2b80d608d61efee834934d862cd92461afc0560dedf493e4c033738b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
"hermit-abi",
cargo update
2024-04-20 09:17:37 -07:00
"libc",
"windows-sys 0.52.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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.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
2024-04-20 09:17:37 -07:00
checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.69"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "29c15563dc2726973df627357ce0c9ddddbea194836909d655df6a75d2cf296d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.153"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "linux-raw-sys"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.13"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
cargo update
2023-07-06 23:45:16 -07: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 = "lock_api"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.4.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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "90ed8c1e510134f979dbc4f070f87d4313098b704861a105fe34231c70a3901c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "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 = [
cargo update
2023-07-06 23:45:16 -07:00
"regex-automata 0.1.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
]
[[package]]
name = "memchr"
cargo update
2024-04-20 09:17:37 -07:00
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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "6c8640c5d730cb13ebd907d8d04b52f55ac9a2eec55b440c8892f40d56c76c1d"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
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
2024-04-20 09:17:37 -07:00
version = "0.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "9d811f3e15f28568be3407c8e7fdb6514c1cda3cb30683f15b6a1a1dc4ea14a7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.8.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
2024-04-20 09:17:37 -07:00
checksum = "a4a650543ca06a924e8b371db273b2756685faae30f8487da1b56505a8f78b0c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"wasi",
cargo update
2024-04-20 09:17:37 -07:00
"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]]
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",
cargo update
2024-04-20 09:17:37 -07:00
"http 0.2.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
"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",
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "num-conv"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
version = "1.16.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
2023-07-06 23:45:16 -07:00
checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
"hermit-abi",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "object"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.32.2"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"memchr",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "once_cell"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.19.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
2024-04-20 09:17:37 -07:00
checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.10.64"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "95a0481286a310808298130d22dd1fef0fa571e05a8f44ec801801e84b216b1f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
"bitflags 2.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
"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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.9.102"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "c597637d56fbc83893a35eb0dd04b2b8e7a50c91e64e9493e398b5df4fb45fa2"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.9.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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
"redox_syscall",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"windows-targets 0.48.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
]
[[package]]
name = "pear"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "bdeeaa00ce488657faba8ebf44ab9361f9365a97bd39ffb8a60663f57ff4b467"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"yansi",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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_codegen"
cargo update
2024-04-20 09:17:37 -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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "4bab5b985dc082b345f812b7df84e1bef27e7207b39e448439ba8bd69c93f147"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
version = "2.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
[[package]]
name = "pin-project"
version = "1.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6bf43b791c5b9e34c3d182969b4abb522f9343702850a2e57f460d00d09b4b3"
dependencies = [
"pin-project-internal",
]
[[package]]
name = "pin-project-internal"
version = "1.1.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "2f38a4412a78282e09a2cf38d195ea5420d15ba0602cb375210efbc877243965"
dependencies = [
"proc-macro2",
"quote",
"syn",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.14"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "bda66fc9667c18cb2758a2ac84d1167245054bcf85d5d1aaa6923f45801bdd02"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.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
2024-04-20 09:17:37 -07:00
checksum = "d231b230927b5e4ad203db57bbcbee2802f6bce620b1e4a9024a07d94e2907ec"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
[[package]]
name = "powerfmt"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.81"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "3d1597b0c024618f09a9c3b8655b7e430397a36d23fdafec26d6965e9eec3eba"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.10.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
2023-09-24 10:49:58 -07:00
checksum = "af066a9c399a26e020ada66a034357a868728e72cd426f3adcd35f80d88d88c8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"yansi",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "quote"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.36"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "redox_syscall"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.4.1"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.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
2024-04-20 09:17:37 -07:00
checksum = "c4846d4c50d1721b1a3bef8af76924eef20d5e723647333798c1b519b3a9473f"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.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
2024-04-20 09:17:37 -07:00
checksum = "5fddb4f8d99b0a2ebafc65a87a69a7b9875e4b1ae1f00db265d300ef7f28bccc"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.10.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
2024-04-20 09:17:37 -07:00
checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
"aho-corasick",
"memchr",
cargo update
2024-04-20 09:17:37 -07:00
"regex-automata 0.4.6",
"regex-syntax 0.8.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
]
[[package]]
name = "regex-automata"
version = "0.1.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c230d73fb8d8c1b9c0b3135c5142a8acee3a0558fb8db5cf1cb65f8d7862132"
dependencies = [
cargo update
2023-04-29 10:34:47 -07:00
"regex-syntax 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
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "regex-automata"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.6"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "86b83b8b9847f9bf95ef68afb0b8e6cdb80f498442f5179a29fad448fcc1eaea"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"aho-corasick",
"memchr",
cargo update
2024-04-20 09:17:37 -07:00
"regex-syntax 0.8.3",
cargo update
2023-07-06 23:45:16 -07: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 = "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
cargo update
2023-04-29 10:34:47 -07:00
[[package]]
name = "regex-syntax"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.8.3"
cargo update
2023-04-29 10:34:47 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "adad44e29e4c806119491a7f06f03de4d1af22c3a680dd47f1e6e179439d1f56"
cargo update
2023-04-29 10:34:47 -07: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 = "reqwest"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.12.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
2024-04-20 09:17:37 -07:00
checksum = "566cafdd92868e0939d3fb961bd0dc25fcfaaed179291093b3d43e6b3150ea10"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"http 1.1.0",
"http-body 1.0.0",
"http-body-util",
"hyper 1.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
"hyper-tls",
cargo update
2024-04-20 09:17:37 -07:00
"hyper-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
"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",
cargo update
2024-04-20 09:17:37 -07:00
"rustls-pemfile",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"serde",
"serde_json",
"serde_urlencoded",
cargo update
2024-04-20 09:17:37 -07:00
"sync_wrapper",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"system-configuration",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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-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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "9e7bb57ccb26670d73b6a47396c83139447b9e7878cab627fdfe9ea8da489150"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"atomic 0.5.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
"binascii",
"bytes",
"either",
"figment",
"futures",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"indexmap",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"yansi",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "rocket_codegen"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "a2238066abf75f21be6cd7dc1a09d5414a671f4246e384e49fe3f8a4936bd04c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"indexmap",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
"rocket_http",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"version_check",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "rocket_http"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "37a1663694d059fe5f943ea5481363e48050acedd241d46deb2e27f71110389e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"http 0.2.12",
"hyper 0.14.28",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"indexmap",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
"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",
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "rustc-demangle"
version = "0.1.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
[[package]]
name = "rustix"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.38.32"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "65e04861e65f21776e67888bfbea442b3642beaa0138fdb1dd7a84a52dffdb89"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
dependencies = [
cargo update
2024-04-20 09:17:37 -07:00
"bitflags 2.5.0",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
"errno",
"libc",
cargo update
2023-09-24 10:49:58 -07:00
"linux-raw-sys",
cargo update
2024-04-20 09:17:37 -07:00
"windows-sys 0.52.0",
]
[[package]]
name = "rustls-pemfile"
version = "2.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29993a25686778eb88d4189742cd713c9bce943bc54251a33509dc63cbacf73d"
dependencies = [
"base64",
"rustls-pki-types",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "rustls-pki-types"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ecd36cc4259e3e4514335c4a138c6b43171a8d61d8f5c9348f9fc7529416f247"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.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
2024-04-20 09:17:37 -07:00
checksum = "80af6f9131f277a45a3fba6ce8e2258037bb0477a67e610d3c1fe046ab31de47"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.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
2024-04-20 09:17:37 -07:00
checksum = "e86697c916019a8588c99b5fac3cead74ec0b4b819707a682fd4d23fa0ce1ba1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07: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
2024-04-20 09:17:37 -07:00
checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
"windows-sys 0.52.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"
cargo update
2023-09-24 10:49:58 -07:00
version = "1.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
2023-09-24 10:49:58 -07:00
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "security-framework"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.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
2024-04-20 09:17:37 -07:00
checksum = "770452e37cad93e0a50d5abc3990d2bc351c36d0328f86cefec2f2fb206eaef6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.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
2024-04-20 09:17:37 -07:00
checksum = "41f3cc463c0ef97e11c3461a9d3787412d30e8e7eb907c79180c4a57bf7c04ef"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.198"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "9846a40c979031340571da2545a4e5b7c4163bdae79b301d5f86d03979451fcc"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.198"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "e88edab869b01783ba905e7d0153f9fc1a6505a96e4ad3018011eedb838566d9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.116"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "serde_spanned"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.6.5"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"serde",
]
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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_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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
[[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"
cargo update
2023-09-24 10:49:58 -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"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
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
2024-04-20 09:17:37 -07:00
version = "1.13.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
2024-04-20 09:17:37 -07:00
checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.5.6"
cargo update
2023-09-24 10:49:58 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "05ffd9c0a93b7543e062e759284fcf5f5e3b098501104bfbdde4d404db792871"
cargo update
2023-09-24 10:49:58 -07:00
dependencies = [
"libc",
cargo update
2024-04-20 09:17:37 -07:00
"windows-sys 0.52.0",
cargo update
2023-09-24 10:49:58 -07: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 = "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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.6.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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "2b8c4a4445d81357df8b1a650d0d0d6fbbbfe99d064aa5e02f3e4022061476d8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = [
"loom",
]
[[package]]
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
name = "syn"
cargo update
2024-04-20 09:17:37 -07:00
version = "2.0.60"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "909518bc7b1c9b779f1bbf07f2929d35af9f0f37e47c6e9ef7f9dddc1e1821f3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "sync_wrapper"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
[[package]]
name = "system-configuration"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
dependencies = [
"bitflags 1.3.2",
"core-foundation",
"system-configuration-sys",
]
[[package]]
name = "system-configuration-sys"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
dependencies = [
"core-foundation-sys",
"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 = "tempfile"
cargo update
2024-04-20 09:17:37 -07:00
version = "3.10.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
2024-04-20 09:17:37 -07:00
checksum = "85b77fafb263dd9d05cbeac119526425676db3784113aa9295c88498cbf8bff1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-09-24 10:49:58 -07:00
"rustix",
cargo update
2024-04-20 09:17:37 -07:00
"windows-sys 0.52.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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.1.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
2024-04-20 09:17:37 -07:00
checksum = "8b9ef9bad013ada3808854ceac7b46812a6465ba368859a37e2100283d2d719c"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.36"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "5dfd88e563464686c916c7e46e623e520ddc6d79fa6641390f2e3fa86e83e885"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-09-24 10:49:58 -07:00
"deranged",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"itoa",
cargo update
2024-04-20 09:17:37 -07:00
"num-conv",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"powerfmt",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.1.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
2023-09-24 10:49:58 -07:00
checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.18"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "3f252a68540fde3a3877aeea552b832b40ab9a69e318efd078774a01ddee1ccf"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
cargo update
2024-04-20 09:17:37 -07:00
"num-conv",
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
"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"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.37.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
2024-04-20 09:17:37 -07:00
checksum = "1adbebffeca75fcfd058afa480fb6c0b81e165a0323f9c9d39c9697e37c46787"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-07-06 23:45:16 -07:00
"backtrace",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2024-04-20 09:17:37 -07:00
"socket2",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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-macros",
cargo update
2024-04-20 09:17:37 -07:00
"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]]
name = "tokio-macros"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.1.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
2024-04-20 09:17:37 -07:00
checksum = "267ac89e0bec6e691e5813911606935d77c476ff49024f98abcea3e7b15e37af"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.7.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.8.12"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "e9dd1545e8208b4a5af1aa9bbd0b4cf7e9ea08fabc5d0a5c67fcaafa17433aa3"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"serde",
"serde_spanned",
"toml_datetime",
"toml_edit",
]
[[package]]
name = "toml_datetime"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.6.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]
cargo update
2023-07-06 23:45:16 -07:00
[[package]]
name = "toml_edit"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.22.12"
cargo update
2023-07-06 23:45:16 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "d3328d4f68a705b2a4498da1d580585d39a6510f98318a2cec3018a7ec61ddef"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
"indexmap",
cargo update
2023-07-06 23:45:16 -07:00
"serde",
"serde_spanned",
"toml_datetime",
"winnow",
]
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "tower"
version = "0.4.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8fa9be0de6cf49e536ce1851f987bd21a43b771b09473c3549a6c853db37c1c"
dependencies = [
"futures-core",
"futures-util",
"pin-project",
"pin-project-lite",
"tokio",
"tower-layer",
"tower-service",
"tracing",
]
[[package]]
name = "tower-layer"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c20c8dbed6283a09604c3e69b4b7eeb54e298b8a600d4d5ecb5ad39de609f1d0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = "tower-service"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
[[package]]
name = "tracing"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.1.40"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
"log",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are now only ARM. ... whereas the Rust function bundler I wrote does not have these problems. So.
2022-06-24 21:16:22 -07:00
"pin-project-lite",
"tracing-attributes",
"tracing-core",
]
[[package]]
name = "tracing-attributes"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.1.27"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.1.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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "ee855f1f400bd0e5c02d150ae5de3840039a3f54b025156404e34c23c03f47c3"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = [
"log",
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -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
"tracing-core",
]
[[package]]
name = "tracing-subscriber"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.3.18"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
version = "0.10.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 (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
checksum = "f720def6ce1ee2fc44d40ac9ed6d3a59c361c80a75a7aa8e75bb9baed31cf2ea"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.9.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "e1b88fcfe09e89d3866a5c11019378088af2d24c3fbd4f0543f96b479ec90697"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
"version_check",
]
[[package]]
name = "unicase"
cargo update
2023-09-24 10:49:58 -07:00
version = "2.7.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
2023-09-24 10:49:58 -07:00
checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = [
"version_check",
]
[[package]]
name = "unicode-bidi"
cargo update
2024-04-20 09:17:37 -07: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
2024-04-20 09:17:37 -07:00
checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-09-24 10:49:58 -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"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07: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
2024-04-20 09:17:37 -07:00
checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
version = "2.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"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-07-06 23:45:16 -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"
cargo update
2023-07-06 23:45:16 -07:00
checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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 = [
"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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "4be2531df63900aeb2bca0daaaddec08491ee64ceecbee5076636a3b026795a8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "614d787b966d3989fa7bb98a654e369c762374fd3213d212cfc0251257e747da"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.4.42"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "76bc14366121efc8dbb487ab05bcc9d346b3b5ec0eaa76e46594cabbe51762c0"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "a1f8823de937b71b9460c0c34e25f3da88250760bec0ebac694b49997550d726"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "e94f17b526d0a461a191c78ea52bbce64071ed5c04c9ffe424dcb38f74171bb7"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
cargo update
2023-05-21 13:56:52 -07:00
"syn",
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.2.92"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "af190c94f2773fdb3729c55b007a722abb5384da03bc0986df4c289bf5567e96"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.3.69"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
checksum = "77afa9a11836342370f4817622a2f0f418b134426d91a82dfb48f532d2ec13ef"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-04-29 10:34:47 -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"
cargo update
2023-04-29 10:34:47 -07:00
checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
dependencies = [
cargo update
2024-04-20 09:17:37 -07:00
"windows-targets 0.48.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
]
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 = [
cargo update
2024-04-20 09:17:37 -07:00
"windows-targets 0.48.5",
]
[[package]]
name = "windows-sys"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
"windows-targets 0.52.5",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
]
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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.5"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
dependencies = [
cargo update
2024-04-20 09:17:37 -07:00
"windows_aarch64_gnullvm 0.48.5",
"windows_aarch64_msvc 0.48.5",
"windows_i686_gnu 0.48.5",
"windows_i686_msvc 0.48.5",
"windows_x86_64_gnu 0.48.5",
"windows_x86_64_gnullvm 0.48.5",
"windows_x86_64_msvc 0.48.5",
]
[[package]]
name = "windows-targets"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6f0713a46559409d202e70e28227288446bf7841d3211583a4b53e3f6d96e7eb"
dependencies = [
"windows_aarch64_gnullvm 0.52.5",
"windows_aarch64_msvc 0.52.5",
"windows_i686_gnu 0.52.5",
"windows_i686_gnullvm",
"windows_i686_msvc 0.52.5",
"windows_x86_64_gnu 0.52.5",
"windows_x86_64_gnullvm 0.52.5",
"windows_x86_64_msvc 0.52.5",
remove lambda support; update deps
2023-04-05 20:58:21 -07:00
]
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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.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"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7088eed71e8b8dda258ecc8bac5fb1153c5cffaf2578fc8ff5d61e23578d3263"
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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.5"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9985fd1504e250c615ca5f281c3f7a6da76213ebd5ccc9561496568a2752afb6"
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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.5"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_i686_gnu"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88ba073cf16d5372720ec942a8ccbf61626074c6d4dd2e745299726ce8b89670"
[[package]]
name = "windows_i686_gnullvm"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87f4261229030a858f36b459e748ae97545d6f1ec60e5e0d6a3d32e0dc232ee9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.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"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_i686_msvc"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db3c2bf3d13d5b658be73463284eaf12830ac9a26a90c717b7f771dfe97487bf"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_gnu"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.5"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4e4246f76bdeff09eb48875a0fd3e2af6aada79d409d33011886d3e1581517d9"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.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"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "852298e482cd67c356ddd9570386e2862b5673c85bd5f88df9ab6802b334c596"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
name = "windows_x86_64_msvc"
cargo update
2023-09-24 10:49:58 -07:00
version = "0.48.5"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2023-09-24 10:49:58 -07:00
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
cargo update
2024-04-20 09:17:37 -07:00
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bec47e5bfd1bff0eeaf6d8b485cc1074891a197ab4225d504cb7a1ab88b02bf0"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
[[package]]
cargo update
2023-07-06 23:45:16 -07:00
name = "winnow"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.6.6"
cargo update; clippy lint fixes
2022-12-27 15:38:54 -08:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "f0c976aaaa0e1f90dbb21e9587cdaf1d9679a1cde8875c0d6bd83ab96a208352"
cargo update
2023-07-06 23:45:16 -07:00
dependencies = [
"memchr",
]
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"
cargo update
2024-04-20 09:17:37 -07:00
version = "0.52.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
2024-04-20 09:17:37 -07:00
checksum = "a277a57398d4bfa075df44f501a17cfdf8542d224f0d36095a2adc7aee4ef0a5"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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
2023-09-24 10:49:58 -07:00
"cfg-if",
cargo update
2024-04-20 09:17:37 -07:00
"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
]
cargo update
2023-09-24 10:49:58 -07:00
[[package]]
name = "yansi"
cargo update
2024-04-20 09:17:37 -07:00
version = "1.0.1"
cargo update
2023-09-24 10:49:58 -07:00
source = "registry+https://github.com/rust-lang/crates.io-index"
cargo update
2024-04-20 09:17:37 -07:00
checksum = "cfe53a6657fd280eaa890a3bc59152892ffa3e30101319d168b781ed6529b049"
cargo update (rocket v0.5!!)
2023-11-17 12:47:50 -08:00
dependencies = [
"is-terminal",
]
cargo update
2023-09-24 10:49:58 -07: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 = "zip"
cargo update
2023-05-21 13:56:52 -07:00
version = "0.6.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
2023-05-21 13:56:52 -07:00
checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261"
Rewrite it in Rust For the curious: this wasn't completely for no reason, although it appears that way from the outside. I deploy this code to AWS via the CDK, and the Python Lambda function bundler in the CDK has two unwanted properties: 1. The assets produced by the bundler are not reproducible, due to the timestamps stored in the .pyc files. The bundler does nothing to assist with this. 2. A bug (that was reported, and that the CDK maintainers converted from an issue into discussion without any investigation) prevents the use of arm64 runtimes with this bundler. This requires emulating x86_64 on my development machines, which are 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",
]