├── .envrc
├── .gitignore
├── .dockerignore
├── .env
├── src
    ├── reddit
    │   ├── mod.rs
    │   ├── api.rs
    │   └── types.rs
    ├── args.rs
    ├── types.rs
    ├── download.rs
    ├── config.rs
    ├── ytdlp.rs
    ├── messages.rs
    ├── bot.rs
    ├── db.rs
    └── main.rs
├── config.example.toml
├── justfile
├── Cargo.toml
├── Dockerfile
├── README.md
└── Cargo.lock


/.envrc:
--------------------------------------------------------------------------------
1 | dotenv
2 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | /target
2 | 


--------------------------------------------------------------------------------
/.dockerignore:
--------------------------------------------------------------------------------
1 | Dockerfile
2 | target/
3 | 


--------------------------------------------------------------------------------
/.env:
--------------------------------------------------------------------------------
1 | CONFIG_PATH=config.toml
2 | RUST_LOG=info
3 | 


--------------------------------------------------------------------------------
/src/reddit/mod.rs:
--------------------------------------------------------------------------------
1 | mod api;
2 | mod types;
3 | pub use api::*;
4 | pub use types::*;
5 | 


--------------------------------------------------------------------------------
/config.example.toml:
--------------------------------------------------------------------------------
1 | db_path = "/data/data.db3"
2 | authorized_user_ids = [123123123]
3 | telegram_bot_token = "xxx"
4 | check_interval_secs = 600
5 | skip_initial_send = true
6 | default_limit = 5
7 | default_time = "week"
8 | 


--------------------------------------------------------------------------------
/justfile:
--------------------------------------------------------------------------------
 1 | build:
 2 |   cargo build
 3 | 
 4 | build-release:
 5 |   cargo build --release
 6 | 
 7 | dev *FLAGS:
 8 |   fd .rs | entr -r cargo run {{FLAGS}}
 9 | 
10 | test *FLAGS:
11 |   cargo test {{FLAGS}}
12 | 
13 | testw *FLAGS:
14 |   fd .rs | entr -r cargo test {{FLAGS}}
15 | 
16 | install:
17 |   cargo install --path .
18 | 


--------------------------------------------------------------------------------
/src/args.rs:
--------------------------------------------------------------------------------
 1 | use getopts::Options;
 2 | use log::*;
 3 | use std::env;
 4 | 
 5 | pub fn parse_args() -> getopts::Matches {
 6 |     let args: Vec<String> = env::args().collect();
 7 |     let mut opts = Options::new();
 8 |     opts.optopt("", "debug-post", "", "");
 9 |     opts.optopt("", "chat-id", "", "");
10 |     match opts.parse(&args[1..]) {
11 |         Ok(m) => m,
12 |         Err(f) => {
13 |             error!("{}", f);
14 |             std::process::exit(1);
15 |         }
16 |     }
17 | }
18 | 


--------------------------------------------------------------------------------
/src/types.rs:
--------------------------------------------------------------------------------
 1 | use crate::reddit::{PostType, TopPostsTimePeriod};
 2 | use std::path::PathBuf;
 3 | 
 4 | #[derive(Debug)]
 5 | pub struct Video {
 6 |     pub path: PathBuf,
 7 |     pub width: u16,
 8 |     pub height: u16,
 9 | }
10 | 
11 | #[derive(Debug, PartialEq, Eq)]
12 | pub struct Subscription {
13 |     pub chat_id: i64,
14 |     pub subreddit: String,
15 |     pub limit: Option<u32>,
16 |     pub time: Option<TopPostsTimePeriod>,
17 |     pub filter: Option<PostType>,
18 | }
19 | 
20 | #[derive(Debug, Clone, PartialEq, Eq)]
21 | pub struct SubscriptionArgs {
22 |     pub subreddit: String,
23 |     pub limit: Option<u32>,
24 |     pub time: Option<TopPostsTimePeriod>,
25 |     pub filter: Option<PostType>,
26 | }
27 | 


--------------------------------------------------------------------------------
/src/download.rs:
--------------------------------------------------------------------------------
 1 | use anyhow::{Context, Result};
 2 | use log::*;
 3 | 
 4 | use std::io::Write;
 5 | use std::{
 6 |     fs::File,
 7 |     path::{Path, PathBuf},
 8 | };
 9 | use tempdir::TempDir;
10 | use url::Url;
11 | 
12 | /// Downloads url to a file and returns the path along with handle to temp dir in which the file is.
13 | /// Whe the temp dir value is dropped, the contents in file system are deleted.
14 | pub async fn download_url_to_tmp(url: &str) -> Result<(PathBuf, TempDir)> {
15 |     info!("downloading {url}");
16 |     let mut res = reqwest::get(url).await?;
17 |     let tmp_dir = TempDir::new("tgreddit")?;
18 |     let parsed_url = Url::parse(url)?;
19 |     let tmp_filename = Path::new(parsed_url.path())
20 |         .file_name()
21 |         .context("could not get basename from url")?;
22 |     let tmp_path = tmp_dir.path().join(tmp_filename);
23 |     let mut file = File::create(&tmp_path)
24 |         .map_err(|_| anyhow::anyhow!("failed to create file {:?}", tmp_path))?;
25 | 
26 |     while let Some(bytes) = res.chunk().await? {
27 |         file.write(&bytes)
28 |             .map_err(|_| anyhow::anyhow!("error writing to file {:?}", tmp_path))?;
29 |     }
30 | 
31 |     info!("downloaded {url} to {}", tmp_path.to_string_lossy());
32 |     Ok((tmp_path, tmp_dir))
33 | }
34 | 


--------------------------------------------------------------------------------
/Cargo.toml:
--------------------------------------------------------------------------------
 1 | [package]
 2 | name = "tgreddit"
 3 | version = "0.1.4"
 4 | edition = "2021"
 5 | description = "Get the top posts of your favorite subreddits to Telegram"
 6 | license = "MIT"
 7 | 
 8 | [dependencies]
 9 | anyhow = "1.0.64"
10 | chrono = "0.4.22"
11 | duct = "0.13.5"
12 | env_logger = "0.9.0"
13 | getopts = "0.2.21"
14 | itertools = "0.10.3"
15 | lazy_static = "1.4.0"
16 | log = "0.4.17"
17 | regex = { version = "1.6.0", default-features = false, features = ["std", "unicode-perl"] }
18 | rusqlite = { version = "0.28.0", features = ["chrono", "bundled"] }
19 | rusqlite_migration = "1.0.0"
20 | secrecy = { version = "0.8.0", features = ["serde"] }
21 | serde = { version = "1.0.144", features = ["derive"] }
22 | serde_derive = "1.0.144"
23 | serde_json = "1.0.85"
24 | signal-hook = "0.3.14"
25 | strum = "0.24.1"
26 | strum_macros = "0.24.3"
27 | teloxide = { version = "0.12.2", features = ["macros", "auto-send"] }
28 | tempdir = "0.3.7"
29 | thiserror = "1.0.34"
30 | tokio = { version = "1.21.0", features = ["rt-multi-thread", "macros", "sync"] }
31 | toml = "0.5.9"
32 | url = "2.2.2"
33 | xdg = "2.4.1"
34 | reqwest = { version = "0.11.11", features = ["json"] }
35 | 
36 | # Use vendored openssl. We don't depend on it directly.
37 | openssl = { version = "0.10.41", features = ["vendored"], optional = true }
38 | 
39 | [features]
40 | vendored-openssl = ["openssl"]
41 | 


--------------------------------------------------------------------------------
/Dockerfile:
--------------------------------------------------------------------------------
 1 | # Step 1: Compute a recipe file
 2 | FROM rust:1.70.0-slim-bookworm as chef
 3 | RUN --mount=type=cache,target=/usr/local/cargo/registry \
 4 |   cargo install cargo-chef
 5 | 
 6 | # Step 2: Compute a recipe file
 7 | FROM chef as planner
 8 | WORKDIR /app
 9 | COPY Cargo.toml Cargo.lock ./
10 | COPY src ./src
11 | RUN cargo chef prepare --recipe-path recipe.json
12 | 
13 | # Step 3: Cache project dependencies
14 | FROM chef as cacher
15 | WORKDIR /app
16 | RUN rustup target add aarch64-unknown-linux-gnu
17 | RUN apt-get update && apt-get install -y \
18 |   gcc-aarch64-linux-gnu musl-tools libssl-dev perl cmake make \
19 |   && rm -rf /var/lib/apt/lists/*
20 | COPY --from=planner /app/recipe.json recipe.json
21 | RUN --mount=type=cache,target=/usr/local/cargo/registry \
22 |   cargo chef cook --release --target aarch64-unknown-linux-gnu --recipe-path recipe.json --features vendored-openssl
23 | 
24 | # Step 4: Build the binary
25 | FROM rust:1.70.0-slim-bookworm as builder
26 | WORKDIR /app
27 | RUN rustup target add aarch64-unknown-linux-gnu
28 | COPY Cargo.toml Cargo.lock ./
29 | COPY src ./src
30 | COPY --from=cacher /app/target target
31 | COPY --from=cacher $CARGO_HOME $CARGO_HOME
32 | RUN --mount=type=cache,target=/usr/local/cargo/registry \
33 |   cargo build --release --target aarch64-unknown-linux-gnu --features vendored-openssl
34 | 
35 | # Step 5: Create the final image with binary and deps
36 | FROM debian:bookworm-slim
37 | WORKDIR /app
38 | COPY --from=builder /app/target/aarch64-unknown-linux-gnu/release/tgreddit .
39 | RUN apt-get update && apt-get install -y \
40 |   curl python3 ffmpeg \
41 |   && rm -rf /var/lib/apt/lists/*
42 | RUN curl -L https://github.com/yt-dlp/yt-dlp/releases/download/2024.04.09/yt-dlp -o /usr/local/bin/yt-dlp
43 | RUN chmod a+rx /usr/local/bin/yt-dlp
44 | ENTRYPOINT ["./tgreddit"]
45 | 


--------------------------------------------------------------------------------
/src/config.rs:
--------------------------------------------------------------------------------
 1 | use log::error;
 2 | use secrecy::{ExposeSecret, Secret};
 3 | use serde::Deserialize;
 4 | use std::{env, path::PathBuf};
 5 | 
 6 | use crate::{
 7 |     reddit::{PostType, TopPostsTimePeriod},
 8 |     PKG_NAME,
 9 | };
10 | 
11 | const CONFIG_PATH_ENV: &str = "CONFIG_PATH";
12 | pub const DEFAULT_LIMIT: u32 = 1;
13 | pub const DEFAULT_TIME_PERIOD: TopPostsTimePeriod = TopPostsTimePeriod::Day;
14 | 
15 | #[derive(Debug, Deserialize)]
16 | pub struct SecretString(Secret<String>);
17 | 
18 | impl SecretString {
19 |     pub fn expose_secret(&self) -> &str {
20 |         self.0.expose_secret()
21 |     }
22 | }
23 | 
24 | impl Default for SecretString {
25 |     fn default() -> Self {
26 |         SecretString(Secret::new("".to_string()))
27 |     }
28 | }
29 | 
30 | #[derive(Deserialize, Debug, Default)]
31 | pub struct Config {
32 |     pub authorized_user_ids: Vec<u64>,
33 |     #[serde(default = "default_db_path")]
34 |     pub db_path: PathBuf,
35 |     pub telegram_bot_token: SecretString,
36 |     pub check_interval_secs: u64,
37 |     #[serde(default = "default_skip_initial_send")]
38 |     pub skip_initial_send: bool,
39 |     pub links_base_url: Option<String>,
40 |     pub default_limit: Option<u32>,
41 |     pub default_time: Option<TopPostsTimePeriod>,
42 |     pub default_filter: Option<PostType>,
43 | }
44 | 
45 | pub fn read_config() -> Config {
46 |     env::var(CONFIG_PATH_ENV)
47 |         .map_err(|_| format!("{CONFIG_PATH_ENV} environment variable not set"))
48 |         .and_then(|config_path| std::fs::read(config_path).map_err(|e| e.to_string()))
49 |         .and_then(|bytes| toml::from_slice(&bytes).map_err(|e| e.to_string()))
50 |         .unwrap_or_else(|err| {
51 |             error!("failed to read config: {err}");
52 |             std::process::exit(1);
53 |         })
54 | }
55 | 
56 | fn default_db_path() -> PathBuf {
57 |     let xdg_dirs = xdg::BaseDirectories::with_prefix(PKG_NAME).unwrap();
58 |     xdg_dirs.place_state_file("data.db3").unwrap()
59 | }
60 | 
61 | fn default_skip_initial_send() -> bool {
62 |     true
63 | }
64 | 


--------------------------------------------------------------------------------
/src/ytdlp.rs:
--------------------------------------------------------------------------------
  1 | use anyhow::Result;
  2 | use duct::cmd;
  3 | use lazy_static::lazy_static;
  4 | use log::{error, info};
  5 | use std::{
  6 |     ffi::OsString,
  7 |     fs,
  8 |     io::{BufRead, BufReader},
  9 |     path::Path,
 10 | };
 11 | 
 12 | use crate::types::*;
 13 | 
 14 | use regex::Regex;
 15 | use tempdir::TempDir;
 16 | 
 17 | fn make_ytdlp_args(output: &Path, url: &str) -> Vec<OsString> {
 18 |     vec![
 19 |         "--paths".into(),
 20 |         output.into(),
 21 |         "--output".into(),
 22 |         // To get telegram show correct aspect ratio for video, we need the dimensions and simplest
 23 |         // way to make that happens is have yt-dlp write them in the filename.
 24 |         "video_%(width)sx%(height)s.%(ext)s".into(),
 25 |         url.into(),
 26 |     ]
 27 | }
 28 | 
 29 | /// Downloads given url with yt-dlp and returns path to video
 30 | pub fn download(url: &str) -> Result<(Video, TempDir)> {
 31 |     let tmp_dir = TempDir::new("tgreddit")?;
 32 |     let tmp_path = tmp_dir.path();
 33 |     let ytdlp_args = make_ytdlp_args(tmp_dir.path(), url);
 34 | 
 35 |     info!("running yt-dlp with arguments {:?}", ytdlp_args);
 36 |     let duct_exp = cmd("yt-dlp", ytdlp_args).stderr_to_stdout();
 37 |     let reader = match duct_exp.reader() {
 38 |         Ok(child) => child,
 39 |         Err(err) => {
 40 |             error!("failed to run yt-dlp:\n{}", err);
 41 |             return Err(anyhow::anyhow!(err));
 42 |         }
 43 |     };
 44 | 
 45 |     let lines = BufReader::new(reader).lines();
 46 |     for line_result in lines {
 47 |         match line_result {
 48 |             Ok(line) => info!("{line}"),
 49 |             Err(_) => {
 50 |                 error!("failed to read yt-dlp output");
 51 |                 return Err(anyhow::anyhow!("failed to read yt-dlp output"));
 52 |             }
 53 |         }
 54 |     }
 55 | 
 56 |     // yt-dlp is expected to write a single file, which is the video, to tmp_path
 57 |     let video_path = fs::read_dir(tmp_path)
 58 |         .expect("could not read files in temp dir")
 59 |         .map(|de| de.unwrap().path())
 60 |         .next()
 61 |         .expect("video file in temp dir");
 62 | 
 63 |     let dimensions =
 64 |         parse_dimensions_from_path(&video_path).expect("video filename should have dimensions");
 65 | 
 66 |     let video = Video {
 67 |         path: video_path,
 68 |         width: dimensions.0,
 69 |         height: dimensions.1,
 70 |     };
 71 | 
 72 |     Ok((video, tmp_dir))
 73 | }
 74 | 
 75 | fn parse_dimensions_from_path(path: &Path) -> Option<(u16, u16)> {
 76 |     lazy_static! {
 77 |         static ref RE: Regex = Regex::new(r"_(?P<width>\d+)x(?P<height>\d+)\.").unwrap();
 78 |     }
 79 | 
 80 |     let path_str = path.to_string_lossy();
 81 |     let caps = RE.captures(&path_str)?;
 82 |     let width = caps.name("width")?.as_str().parse::<u16>().ok()?;
 83 |     let height = caps.name("height")?.as_str().parse::<u16>().ok()?;
 84 | 
 85 |     Some((width, height))
 86 | }
 87 | 
 88 | #[cfg(test)]
 89 | mod tests {
 90 |     use super::parse_dimensions_from_path;
 91 |     use std::path::Path;
 92 | 
 93 |     #[test]
 94 |     fn test_parse_dimensions_from_path() {
 95 |         assert_eq!(
 96 |             parse_dimensions_from_path(Path::new("/foo/bar/video_1920x1080.mp4")),
 97 |             Some((1920, 1080))
 98 |         );
 99 | 
100 |         assert_eq!(
101 |             parse_dimensions_from_path(Path::new("/foo/bar/video_asdfax1080.mp4")),
102 |             None,
103 |         );
104 |     }
105 | }
106 | 


--------------------------------------------------------------------------------
/src/messages.rs:
--------------------------------------------------------------------------------
  1 | use crate::reddit;
  2 | use crate::*;
  3 | use itertools::Itertools;
  4 | 
  5 | fn escape(html: &str) -> String {
  6 |     html.replace('<', "&lt;").replace('>', "&gt;")
  7 | }
  8 | 
  9 | fn format_html_anchor(href: &str, text: &str) -> String {
 10 |     format!(r#"<a href="{href}">{}</a>"#, escape(text))
 11 | }
 12 | 
 13 | fn format_subreddit_link(subreddit: &str, base_url: Option<&str>) -> String {
 14 |     format_html_anchor(
 15 |         &reddit::format_subreddit_url(subreddit, base_url),
 16 |         &format!("/r/{}", &subreddit),
 17 |     )
 18 | }
 19 | 
 20 | fn format_meta_html(post: &reddit::Post, links_base_url: Option<&str>) -> String {
 21 |     let subreddit_link = format_subreddit_link(&post.subreddit, links_base_url);
 22 |     let comments_link = format_html_anchor(&post.format_permalink_url(links_base_url), "comments");
 23 | 
 24 |     // If using custom links base url, the old reddit link doesn't make sense.
 25 |     match links_base_url {
 26 |         Some(_) => format!("{subreddit_link} [{comments_link}]"),
 27 |         None => {
 28 |             let old_comments_link = format_html_anchor(&post.format_old_permalink_url(), "old");
 29 |             format!("{subreddit_link} [{comments_link}, {old_comments_link}]")
 30 |         }
 31 |     }
 32 | }
 33 | 
 34 | pub fn format_media_caption_html(post: &reddit::Post, links_base_url: Option<&str>) -> String {
 35 |     let title = &post.title;
 36 |     let meta = format_meta_html(post, links_base_url);
 37 |     format!("{title}\n{meta}")
 38 | }
 39 | 
 40 | pub fn format_link_message_html(post: &reddit::Post, links_base_url: Option<&str>) -> String {
 41 |     let title = format_html_anchor(&post.url, &post.title);
 42 |     let meta = format_meta_html(post, links_base_url);
 43 |     format!("{title}\n{meta}")
 44 | }
 45 | 
 46 | pub fn format_subscription_list(post: &[Subscription]) -> String {
 47 |     fn format_subscription(sub: &Subscription) -> String {
 48 |         let mut args = vec![];
 49 |         if let Some(time) = sub.time {
 50 |             args.push(format!("time={}", time));
 51 |         }
 52 |         if let Some(limit) = sub.limit {
 53 |             args.push(format!("limit={}", limit));
 54 |         }
 55 |         if let Some(filter) = sub.filter {
 56 |             args.push(format!("filter={}", filter));
 57 |         }
 58 | 
 59 |         let args_str = if !args.is_empty() {
 60 |             format!("({})", args.join(", "))
 61 |         } else {
 62 |             "".to_string()
 63 |         };
 64 | 
 65 |         [sub.subreddit.to_owned(), args_str]
 66 |             .join(" ")
 67 |             .trim_end()
 68 |             .to_string()
 69 |     }
 70 | 
 71 |     if post.is_empty() {
 72 |         "No subscriptions".to_owned()
 73 |     } else {
 74 |         post.iter().map(format_subscription).join("\n")
 75 |     }
 76 | }
 77 | 
 78 | #[cfg(test)]
 79 | mod tests {
 80 |     use super::*;
 81 | 
 82 |     #[test]
 83 |     fn test_format_html_anchor() {
 84 |         assert_eq!(
 85 |             format_html_anchor("https://example.com", "<hello></world>"),
 86 |             r#"<a href="https://example.com">&lt;hello&gt;&lt;/world&gt;</a>"#
 87 |         )
 88 |     }
 89 | 
 90 |     #[test]
 91 |     fn test_format_subscription_list() {
 92 |         assert_eq!(
 93 |             format_subscription_list(&[
 94 |                 Subscription {
 95 |                     chat_id: 1,
 96 |                     subreddit: "foo".to_owned(),
 97 |                     limit: None,
 98 |                     time: None,
 99 |                     filter: None,
100 |                 },
101 |                 Subscription {
102 |                     chat_id: 1,
103 |                     subreddit: "bar".to_owned(),
104 |                     limit: Some(1),
105 |                     time: Some(TopPostsTimePeriod::Week),
106 |                     filter: None,
107 |                 },
108 |             ]),
109 |             "foo\nbar (time=week, limit=1)"
110 |         )
111 |     }
112 | }
113 | 


--------------------------------------------------------------------------------
/src/reddit/api.rs:
--------------------------------------------------------------------------------
  1 | use super::*;
  2 | use anyhow::{Context, Result};
  3 | use log::{error, info};
  4 | use thiserror::Error;
  5 | use url::Url;
  6 | 
  7 | static REDDIT_BASE_URL: &str = "https://www.reddit.com";
  8 | static APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
  9 | 
 10 | fn get_base_url() -> Url {
 11 |     Url::parse(REDDIT_BASE_URL).unwrap()
 12 | }
 13 | 
 14 | fn get_client() -> reqwest::ClientBuilder {
 15 |     reqwest::Client::builder().user_agent(APP_USER_AGENT)
 16 | }
 17 | 
 18 | pub fn format_url_from_path(path: &str, base_url: Option<&str>) -> String {
 19 |     let base_url = match base_url {
 20 |         Some(u) => u,
 21 |         None => REDDIT_BASE_URL,
 22 |     };
 23 |     format!("{base_url}{path}")
 24 | }
 25 | 
 26 | pub fn to_old_reddit_url(url: &str) -> String {
 27 |     // If this fails it's bug
 28 |     let mut url = Url::parse(url).unwrap();
 29 |     url.set_host(Some("old.reddit.com")).unwrap();
 30 |     url.to_string()
 31 | }
 32 | 
 33 | pub fn format_subreddit_url(subreddit: &str, base_url: Option<&str>) -> String {
 34 |     format_url_from_path(&format!("/r/{subreddit}"), base_url)
 35 | }
 36 | 
 37 | pub async fn get_subreddit_top_posts(
 38 |     subreddit: &str,
 39 |     limit: u32,
 40 |     time: &TopPostsTimePeriod,
 41 | ) -> Result<Vec<Post>> {
 42 |     info!("getting top posts for /r/{subreddit} limit={limit} time={time:?}");
 43 |     let url = get_base_url()
 44 |         .join(&format!("/r/{subreddit}/top.json"))
 45 |         .unwrap();
 46 |     let client = get_client().build()?;
 47 |     let res = client
 48 |         .get(url)
 49 |         .query(&[
 50 |             ("limit", &limit.to_string()),
 51 |             ("t", &format!("{:?}", time).to_lowercase()),
 52 |         ])
 53 |         .send()
 54 |         .await?
 55 |         .json::<ListingResponse>()
 56 |         .await?;
 57 |     let posts = res.data.children.into_iter().map(|e| e.data).collect();
 58 |     Ok(posts)
 59 | }
 60 | 
 61 | pub async fn get_link(link_id: &str) -> Result<Post> {
 62 |     info!("getting link id {link_id}");
 63 |     let url = get_base_url().join("/api/info.json")?;
 64 |     let client = get_client().build()?;
 65 |     let res = client
 66 |         .get(url)
 67 |         .query(&[("id", &format!("t3_{link_id}"))])
 68 |         .send()
 69 |         .await
 70 |         .context("failed to send request")?;
 71 | 
 72 |     let status = res.status();
 73 |     let body = res.text().await.context("failed to read response body")?;
 74 | 
 75 |     if !status.is_success() {
 76 |         error!("request failed with status: {}", status);
 77 |         error!("response body: {}", body);
 78 |         anyhow::bail!("Request failed with status: {}", status);
 79 |     }
 80 | 
 81 |     match serde_json::from_str::<ListingResponse>(&body) {
 82 |         Ok(parsed) => parsed
 83 |             .data
 84 |             .children
 85 |             .into_iter()
 86 |             .map(|e| e.data)
 87 |             .next()
 88 |             .context("no post in response")
 89 |             .map_err(|e| {
 90 |                 error!("failed to get posts for {link_id}: {:?}", e);
 91 |                 e
 92 |             }),
 93 |         Err(e) => {
 94 |             error!("error decoding response body: {}", e);
 95 |             error!("response body: {}", body);
 96 |             Err(anyhow::anyhow!("error decoding response body: {}", e))
 97 |         }
 98 |     }
 99 | }
100 | 
101 | #[allow(clippy::large_enum_variant)]
102 | #[derive(Error, Debug)]
103 | pub enum SubredditAboutError {
104 |     #[error("no such subreddit")]
105 |     NoSuchSubreddit,
106 |     #[error(transparent)]
107 |     Reqwest(#[from] reqwest::Error),
108 |     #[error(transparent)]
109 |     UrlParseError(#[from] url::ParseError),
110 |     #[error(transparent)]
111 |     IO(#[from] std::io::Error),
112 | }
113 | 
114 | pub async fn get_subreddit_about(subreddit: &str) -> Result<SubredditAbout, SubredditAboutError> {
115 |     info!("getting subreddit about for /r/{subreddit}");
116 |     let client = get_client()
117 |         .redirect(reqwest::redirect::Policy::none())
118 |         .build()?;
119 |     let url = get_base_url().join(&format!("/r/{subreddit}/about.json"))?;
120 |     let res = client.get(url).send().await?;
121 | 
122 |     match res.status() {
123 |         reqwest::StatusCode::FOUND => Err(SubredditAboutError::NoSuchSubreddit),
124 |         _ => {
125 |             let data = res.json::<SubredditAboutResponse>().await?.data;
126 |             Ok(data)
127 |         }
128 |     }
129 | }
130 | 


--------------------------------------------------------------------------------
/src/reddit/types.rs:
--------------------------------------------------------------------------------
  1 | use std::collections::HashMap;
  2 | 
  3 | use super::*;
  4 | use anyhow::{Context, Result};
  5 | use serde::{Deserialize, Deserializer};
  6 | use strum_macros::{Display, EnumString};
  7 | use url::Url;
  8 | 
  9 | #[derive(Display, Debug, Clone, PartialEq, Hash, Eq, Deserialize, Copy, EnumString)]
 10 | #[serde(rename_all = "snake_case")]
 11 | #[strum(serialize_all = "snake_case")]
 12 | pub enum PostType {
 13 |     Image,
 14 |     Video,
 15 |     Link,
 16 |     SelfText,
 17 |     Gallery,
 18 |     Unknown,
 19 | }
 20 | 
 21 | #[derive(Display, Debug, Clone, PartialEq, Hash, Eq, Deserialize, Copy, EnumString)]
 22 | #[serde(rename_all = "snake_case")]
 23 | #[strum(serialize_all = "snake_case")]
 24 | pub enum TopPostsTimePeriod {
 25 |     Hour,
 26 |     Day,
 27 |     Week,
 28 |     Month,
 29 |     Year,
 30 |     All,
 31 | }
 32 | 
 33 | #[derive(Deserialize, Debug)]
 34 | pub struct ListingResponse {
 35 |     pub data: ListingResponseData,
 36 | }
 37 | 
 38 | #[derive(Deserialize, Debug)]
 39 | pub struct ListingResponseData {
 40 |     pub children: Vec<ListingItem>,
 41 | }
 42 | 
 43 | #[derive(Deserialize, Debug)]
 44 | pub struct ListingItem {
 45 |     pub data: Post,
 46 | }
 47 | 
 48 | #[derive(Deserialize, Debug, Clone)]
 49 | pub struct GalleryDataItem {
 50 |     pub caption: Option<String>,
 51 |     pub media_id: String,
 52 |     pub id: u32,
 53 | }
 54 | 
 55 | #[derive(Deserialize, Debug, Clone)]
 56 | pub struct GalleryData {
 57 |     pub items: Vec<GalleryDataItem>,
 58 | }
 59 | 
 60 | #[derive(Deserialize, Debug, Clone)]
 61 | pub struct Media {
 62 |     pub x: u16,
 63 |     pub y: u16,
 64 |     #[serde(rename = "u")]
 65 |     pub url: String,
 66 | }
 67 | 
 68 | #[derive(Deserialize, Debug, Clone)]
 69 | pub struct MediaMetadata {
 70 |     pub status: String,
 71 |     pub e: String,
 72 |     #[serde(rename = "m")]
 73 |     pub mime: String,
 74 |     pub s: Media,
 75 | }
 76 | 
 77 | #[derive(Debug, Clone)]
 78 | pub struct Post {
 79 |     pub id: String,
 80 |     pub created: f32,
 81 |     pub subreddit: String,
 82 |     pub title: String,
 83 |     pub is_video: bool,
 84 |     pub ups: u32,
 85 |     pub permalink: String,
 86 |     pub url: String,
 87 |     pub post_hint: Option<String>,
 88 |     pub is_self: bool,
 89 |     pub is_gallery: Option<bool>,
 90 |     pub post_type: PostType,
 91 |     pub crosspost_parent_list: Option<Vec<Post>>,
 92 |     pub gallery_data: Option<GalleryData>,
 93 |     pub media_metadata: Option<HashMap<String, MediaMetadata>>,
 94 | }
 95 | 
 96 | impl<'de> Deserialize<'de> for Post {
 97 |     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 98 |     where
 99 |         D: Deserializer<'de>,
100 |     {
101 |         #[derive(Deserialize)]
102 |         pub struct PostHelper {
103 |             pub id: String,
104 |             pub created: f32,
105 |             pub subreddit: String,
106 |             pub title: String,
107 |             pub is_video: bool,
108 |             pub ups: u32,
109 |             pub permalink: String,
110 |             pub url: String,
111 |             pub post_hint: Option<String>,
112 |             pub is_self: bool,
113 |             pub is_gallery: Option<bool>,
114 |             pub crosspost_parent_list: Option<Vec<Post>>,
115 |             pub gallery_data: Option<GalleryData>,
116 |             pub media_metadata: Option<HashMap<String, MediaMetadata>>,
117 |         }
118 | 
119 |         impl PostHelper {
120 |             pub fn is_downloadable_video(&self) -> bool {
121 |                 let is_downloadable_3rd_party = || -> Result<bool> {
122 |                     let url = Url::parse(&self.url)?;
123 |                     let host = url.host_str().context("no host in url")?;
124 |                     let path = url.path();
125 |                     let is_imgur_gif = host == "i.imgur.com" && path.ends_with(".gifv");
126 |                     let is_gfycat_gif = host == "gfycat.com";
127 |                     Ok(is_imgur_gif || is_gfycat_gif)
128 |                 };
129 | 
130 |                 // If the post is a crosspost with a video, it can be downloaded with post.url as
131 |                 // url as yt-dlp follows redirects
132 |                 let is_downloadable_crosspost = || -> bool {
133 |                     self.crosspost_parent_list
134 |                         .as_ref()
135 |                         .map(|list| list.iter().any(|post| post.post_type == PostType::Video))
136 |                         .unwrap_or(false)
137 |                 };
138 | 
139 |                 self.is_video
140 |                     || is_downloadable_crosspost()
141 |                     || is_downloadable_3rd_party().unwrap_or(false)
142 |             }
143 |         }
144 | 
145 |         let helper = PostHelper::deserialize(deserializer)?;
146 |         let post_hint = helper.post_hint.as_deref();
147 |         let post_type = if helper.is_downloadable_video() {
148 |             PostType::Video
149 |         } else if post_hint == Some("image") {
150 |             PostType::Image
151 |         // post_hint => rich:video can be a link to a youtube video, which are not worthwhile to
152 |         // download due to their length, though exceptions could be made for short (< 1min) videos
153 |         } else if post_hint == Some("link") || post_hint == Some("rich:video") {
154 |             PostType::Link
155 |         } else if helper.is_self {
156 |             PostType::SelfText
157 |         } else if helper.is_gallery.unwrap_or(false) {
158 |             PostType::Gallery
159 |         } else {
160 |             PostType::Unknown
161 |         };
162 | 
163 |         Ok(Post {
164 |             id: helper.id,
165 |             created: helper.created,
166 |             subreddit: helper.subreddit,
167 |             title: helper.title,
168 |             is_video: helper.is_video,
169 |             ups: helper.ups,
170 |             permalink: helper.permalink,
171 |             url: helper.url,
172 |             post_hint: helper.post_hint,
173 |             is_self: helper.is_self,
174 |             crosspost_parent_list: helper.crosspost_parent_list,
175 |             is_gallery: helper.is_gallery,
176 |             post_type,
177 |             gallery_data: helper.gallery_data,
178 |             media_metadata: helper.media_metadata,
179 |         })
180 |     }
181 | }
182 | 
183 | impl Post {
184 |     pub(crate) fn format_permalink_url(&self, base_url: Option<&str>) -> String {
185 |         format_url_from_path(&self.permalink, base_url)
186 |     }
187 | 
188 |     pub(crate) fn format_old_permalink_url(&self) -> String {
189 |         to_old_reddit_url(&format_url_from_path(&self.permalink, None))
190 |     }
191 | }
192 | 
193 | #[derive(Deserialize, Debug)]
194 | pub struct SubredditAboutResponse {
195 |     pub data: SubredditAbout,
196 | }
197 | 
198 | #[derive(Deserialize, Debug)]
199 | pub struct SubredditAbout {
200 |     pub display_name: String,
201 |     pub display_name_prefixed: String,
202 | }
203 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # tgreddit
  2 | 
  3 | A telegram bot that gives you a feed of top posts from your favorite subreddits.
  4 | 
  5 | The killer feature: No need to visit Reddit, as all media is embedded thanks to
  6 | [yt-dlp][yt-dlp] and Telegram's excellent media support.
  7 | 
  8 | Intended to be self-hosted, as Reddit's API has rate-limiting and downloading
  9 | videos with `yt-dlp` can be resource intensive. The simplest way to self-host is
 10 | to use the prebuilt [docker image](#docker-image) that includes necessary
 11 | dependencies.
 12 | 
 13 | <img align=left src="https://user-images.githubusercontent.com/11027/178097057-83b27933-9876-405a-b151-a148960819df.jpeg" width=20% height=20%>
 14 | <img align=left src="https://user-images.githubusercontent.com/11027/178096986-5f651336-8208-4c40-9c41-58c95173b24d.jpeg" width=20% height=20%>
 15 | <img src="https://user-images.githubusercontent.com/11027/178099572-e55c7f3c-986b-4804-8540-1004b36950df.jpeg" width=20% height=20%>
 16 | 
 17 | ## install
 18 | 
 19 | ```sh
 20 | $ cargo install tgreddit
 21 | ```
 22 | 
 23 | ### requirements
 24 | 
 25 | Depends on [yt-dlp][yt-dlp] (and for good results, yt-dlp requires ffmpeg).
 26 | 
 27 | ## bot commands
 28 | 
 29 | ### `/sub <subreddit> [limit=<limit>] [time=<time>] [filter=<filter>]`
 30 | 
 31 | Add a subscription to subreddit's top posts with optional options. Subscriptions
 32 | are conversation specific, and may be added in channels where the bot is
 33 | participating or in private chats with the bot.
 34 | 
 35 | If the options are not given, when checking for new posts, the program will
 36 | default to configuration in config.toml, if any.
 37 | 
 38 | Example: `/sub AnimalsBeingJerks limit=5 time=week filter=video`
 39 | 
 40 | Explanation: Subscribe to top posts in r/AnimalsBeingJerks so that the top 5
 41 | posts of the weekly top list are considered. Whenever a new post appears among
 42 | those top 5 posts, they will be posted in the conversation.
 43 | 
 44 | See the
 45 | [example configuration](#example-toml-configuration-with-the-options-explained)
 46 | below for further explanation on `limit`, `time`, and `filter`.
 47 | 
 48 | ### `/unsub <subreddit>`
 49 | 
 50 | Remove a subscription from the current conversation.
 51 | 
 52 | ### `/listsubs`
 53 | 
 54 | List all subreddit subscriptions for the current conversation.
 55 | 
 56 | ### `/get <subreddit> [limit=<limit>] [time=<time>] [filter=<filter>]`
 57 | 
 58 | Get the current top posts similarly to how subscribing to a subreddit would
 59 | return new posts.
 60 | 
 61 | ## configuration
 62 | 
 63 | ### env vars
 64 | 
 65 | - `CONFIG_PATH`: Path to TOML configuration file. **required**
 66 | - `RUST_LOG`: Logging level. `info` recommended to see meaningful output.
 67 | 
 68 | ### example toml configuration with the options explained
 69 | 
 70 | Example config without comments:
 71 | [config.example.toml](https://raw.githubusercontent.com/raine/tgreddit/master/config.example.toml)
 72 | 
 73 | ```toml
 74 | # Path to a SQLite database used to track seen posts.
 75 | # Optional. Defaults to $HOME/.local/state/tgreddit/data.db3.
 76 | db_path = "/path/to/data.db3"
 77 | 
 78 | # List of Telegram user ids that can use the commands provided by the bot.
 79 | authorized_users = [
 80 |   123123123
 81 | ]
 82 | 
 83 | # Token of your Telegram bot - you get this from @botfather.
 84 | telegram_bot_token = "..."
 85 | 
 86 | # How often to query each configured subreddit for new posts. Applies only if
 87 | # keep_running is enabled.
 88 | check_interval_secs = 600
 89 | 
 90 | # Whether posts seen on the first check of a new subreddit are considered new
 91 | # or not. Generally having this enabled is better unless you want multiple new
 92 | # messages when a new subreddit is added.
 93 | # Optional. Defaults to true.
 94 | skip_initial_send = true
 95 | 
 96 | # Set the post comments links to use an alternative frontend. Useful as the
 97 | # official Reddit web app is increasingly user hostile on mobile. Possible
 98 | # alternative frontends include teddit.net and libredd.it, but you can use any.
 99 | # Optional. Defaults to official Reddit.
100 | links_base_url = "https://teddit.net"
101 | 
102 | # Set default limit of posts to fetch for each subreddit. Used when not
103 | # specified for a subreddit in the /sub command.
104 | #
105 | # Explanation in more detail: Whenever the bot gets the list of top posts for a
106 | # subreddit, it will only consider the first <limit> posts. For example, if
107 | # your limit is 5, the first time around bot will see 5 new posts and mark those
108 | # as seen and not post anything because it's the first check. Next time around, if
109 | # there's an unseen post among those 5 top posts, it will be posted in Telegram.
110 | #
111 | # So essentially larger the number used as limit, the more posts you can
112 | # expect to see. For example, with time=month and limit=1 you would see a new post
113 | # only when the montly top post changes, which is not that often.
114 | #
115 | # Optional. The default is 1.
116 | default_limit = 1
117 | 
118 | # Set default time period of top list fetched. Used when not specified for a
119 | # subreddit. String and one of: hour, day, week, month, year, all.
120 | # Optional. The default is `day`.
121 | default_time = "day"
122 | 
123 | # Set default filter for post type. When fetching for new posts, only posts
124 | # matching the filter are considered.
125 | # String and one of: image, video, link, self_text, gallery
126 | # Optional and unset by default, meaning all post types are considered.
127 | default_filter = "video"
128 | ```
129 | 
130 | Perhaps the simplest way to determine a Telegram channel's ID is to open the
131 | channel in [Telegram Web client][telegram-web] and observing the numeric value
132 | in page URL.
133 | 
134 | ## development
135 | 
136 | The project uses [`just`][just], [`direnv`][direnv] and [`entr`][entr].
137 | 
138 | ```sh
139 | $ just dev
140 | ```
141 | 
142 | ## docker image
143 | 
144 | There's a prebuilt Docker image with dependencies included at
145 | [rainevi/tgreddit](https://hub.docker.com/repository/docker/rainevi/tgreddit).
146 | 
147 | Of course, you may also build your own using from the
148 | [Dockerfile](https://raw.githubusercontent.com/raine/tgreddit/master/Dockerfile).
149 | 
150 | ## cross compiling for Raspberry Pi
151 | 
152 | You can cross-compile tgreddit for Raspberry Pi using a Docker container. The
153 | resulting executable will be statically linked and should work across different
154 | Linux distributions on the Raspberry Pi.
155 | 
156 | ```sh
157 | docker run --rm -it \
158 | 	-v "$(pwd)":/home/rust/src messense/rust-musl-cross:aarch64-musl \
159 | 	cargo build --release --target aarch64-unknown-linux-gnu --features vendored-openssl
160 | ```
161 | 
162 | ## have an idea, question or a bug report?
163 | 
164 | Feel free to open an issue or start a new discussion.
165 | 
166 | [yt-dlp]: https://github.com/yt-dlp/yt-dlp
167 | [telegram-web]: https://web.telegram.org/
168 | [just]: https://github.com/casey/just
169 | [direnv]: https://direnv.net/
170 | [entr]: https://github.com/eradman/entr
171 | 


--------------------------------------------------------------------------------
/src/bot.rs:
--------------------------------------------------------------------------------
  1 | use crate::*;
  2 | use anyhow::Result;
  3 | use lazy_static::lazy_static;
  4 | use regex::Regex;
  5 | use std::sync::Arc;
  6 | use teloxide::{
  7 |     dispatching::DefaultKey,
  8 |     utils::command::{BotCommands, ParseError},
  9 | };
 10 | 
 11 | #[derive(BotCommands, Clone)]
 12 | #[command(
 13 |     rename_rule = "lowercase",
 14 |     description = "These commands are supported:"
 15 | )]
 16 | pub enum Command {
 17 |     #[command(description = "display this text")]
 18 |     Help,
 19 |     #[command(
 20 |         description = "subscribe to subreddit's top posts",
 21 |         parse_with = parse_subscribe_message
 22 |     )]
 23 |     Sub(SubscriptionArgs),
 24 |     #[command(description = "unsubscribe from subreddit's top posts")]
 25 |     Unsub(String),
 26 |     #[command(description = "list subreddit subscriptions")]
 27 |     ListSubs,
 28 |     #[command(description = "get top posts", parse_with = parse_subscribe_message)]
 29 |     Get(SubscriptionArgs),
 30 | }
 31 | 
 32 | pub struct MyBot {
 33 |     pub dispatcher: Dispatcher<Arc<Bot>, anyhow::Error, DefaultKey>,
 34 |     pub tg: Arc<Bot>,
 35 | }
 36 | 
 37 | impl MyBot {
 38 |     pub async fn new(config: Arc<config::Config>) -> Result<Self> {
 39 |         let tg = Arc::new(Bot::new(config.telegram_bot_token.expose_secret()));
 40 |         tg.set_my_commands(Command::bot_commands()).await?;
 41 | 
 42 |         let handler = Update::filter_message().branch(
 43 |             dptree::filter(|msg: Message, config: Arc<config::Config>| {
 44 |                 msg.from()
 45 |                     .map(|user| config.authorized_user_ids.contains(&user.id.0))
 46 |                     .unwrap_or_default()
 47 |             })
 48 |             .filter_command::<Command>()
 49 |             .endpoint(handle_command),
 50 |         );
 51 | 
 52 |         let dispatcher = Dispatcher::builder(tg.clone(), handler)
 53 |             .dependencies(dptree::deps![config.clone()])
 54 |             .default_handler(|upd| async move {
 55 |                 warn!("unhandled update: {:?}", upd);
 56 |             })
 57 |             .error_handler(LoggingErrorHandler::with_custom_text(
 58 |                 "an error has occurred in the dispatcher",
 59 |             ))
 60 |             .build();
 61 | 
 62 |         let my_bot = MyBot {
 63 |             dispatcher,
 64 |             tg: tg.clone(),
 65 |         };
 66 |         Ok(my_bot)
 67 |     }
 68 | 
 69 |     pub fn spawn(
 70 |         mut self,
 71 |     ) -> (
 72 |         tokio::task::JoinHandle<()>,
 73 |         teloxide::dispatching::ShutdownToken,
 74 |     ) {
 75 |         let shutdown_token = self.dispatcher.shutdown_token();
 76 |         (
 77 |             tokio::spawn(async move { self.dispatcher.dispatch().await }),
 78 |             shutdown_token,
 79 |         )
 80 |     }
 81 | }
 82 | 
 83 | pub async fn handle_command(
 84 |     message: Message,
 85 |     tg: Arc<Bot>,
 86 |     command: Command,
 87 |     config: Arc<config::Config>,
 88 | ) -> Result<()> {
 89 |     async fn handle(
 90 |         message: &Message,
 91 |         tg: &Bot,
 92 |         command: Command,
 93 |         config: Arc<config::Config>,
 94 |     ) -> Result<()> {
 95 |         match command {
 96 |             Command::Help => {
 97 |                 tg.send_message(message.chat.id, Command::descriptions().to_string())
 98 |                     .await?;
 99 |             }
100 |             Command::Sub(mut args) => {
101 |                 let db = db::Database::open(&config)?;
102 |                 let chat_id = message.chat.id.0;
103 |                 let subreddit_about = reddit::get_subreddit_about(&args.subreddit).await;
104 |                 match subreddit_about {
105 |                     Ok(data) => {
106 |                         args.subreddit = data.display_name;
107 |                         db.subscribe(chat_id, &args)?;
108 |                         info!("subscribed in chat id {chat_id} with {args:#?};");
109 |                         tg.send_message(
110 |                             ChatId(chat_id),
111 |                             format!("Subscribed to r/{}", args.subreddit),
112 |                         )
113 |                         .await?;
114 |                     }
115 |                     Err(reddit::SubredditAboutError::NoSuchSubreddit) => {
116 |                         tg.send_message(ChatId(chat_id), "No such subreddit")
117 |                             .await?;
118 |                     }
119 |                     Err(err) => {
120 |                         Err(err)?;
121 |                     }
122 |                 }
123 |             }
124 |             Command::Unsub(subreddit) => {
125 |                 let db = db::Database::open(&config)?;
126 |                 let chat_id = message.chat.id.0;
127 |                 let subreddit = subreddit.replace("r/", "");
128 |                 let reply = match db.unsubscribe(chat_id, &subreddit) {
129 |                     Ok(sub) => format!("Unsubscribed from r/{sub}"),
130 |                     Err(_) => format!("Error: Not subscribed to r/{subreddit}"),
131 |                 };
132 |                 tg.send_message(ChatId(chat_id), reply).await?;
133 |             }
134 |             Command::ListSubs => {
135 |                 let db = db::Database::open(&config)?;
136 |                 let subs = db.get_subscriptions_for_chat(message.chat.id.0)?;
137 |                 let reply = messages::format_subscription_list(&subs);
138 |                 tg.send_message(message.chat.id, reply).await?;
139 |             }
140 |             Command::Get(args) => {
141 |                 let subreddit = &args.subreddit;
142 |                 let limit = args
143 |                     .limit
144 |                     .or(config.default_limit)
145 |                     .unwrap_or(config::DEFAULT_LIMIT);
146 |                 let time = args
147 |                     .time
148 |                     .or(config.default_time)
149 |                     .unwrap_or(config::DEFAULT_TIME_PERIOD);
150 |                 let filter = args.filter.or(config.default_filter);
151 |                 let chat_id = message.chat.id.0;
152 | 
153 |                 let posts = reddit::get_subreddit_top_posts(subreddit, limit, &time)
154 |                     .await
155 |                     .context("failed to get posts")?
156 |                     .into_iter()
157 |                     .filter(|p| {
158 |                         if filter.is_some() {
159 |                             filter.as_ref() == Some(&p.post_type)
160 |                         } else {
161 |                             true
162 |                         }
163 |                     })
164 |                     .collect::<Vec<_>>();
165 | 
166 |                 debug!("got {} post(s) for subreddit /r/{}", posts.len(), subreddit);
167 | 
168 |                 if !posts.is_empty() {
169 |                     for post in posts {
170 |                         if let Err(e) = handle_new_post(&config, tg, chat_id, &post).await {
171 |                             error!("failed to handle new post: {e}");
172 |                         }
173 |                     }
174 |                 } else {
175 |                     tg.send_message(message.chat.id, "No posts found").await?;
176 |                 }
177 |             }
178 |         };
179 | 
180 |         Ok(())
181 |     }
182 | 
183 |     if let Err(err) = handle(&message, &tg, command, config).await {
184 |         error!("failed to handle message: {}", err);
185 |         tg.send_message(message.chat.id, "Something went wrong")
186 |             .await?;
187 |     }
188 | 
189 |     Ok(())
190 | }
191 | 
192 | fn parse_subscribe_message(input: String) -> Result<(SubscriptionArgs,), ParseError> {
193 |     lazy_static! {
194 |         static ref SUBREDDIT_RE: Regex = Regex::new(r"^[^\s]+").unwrap();
195 |         static ref LIMIT_RE: Regex = Regex::new(r"\blimit=(\d+)\b").unwrap();
196 |         static ref TIME_RE: Regex = Regex::new(r"\btime=(\w+)\b").unwrap();
197 |         static ref FILTER_RE: Regex = Regex::new(r"\bfilter=(\w+)\b").unwrap();
198 |     }
199 | 
200 |     let subreddit_match = SUBREDDIT_RE
201 |         .find(&input)
202 |         .ok_or_else(|| ParseError::Custom("No subreddit given".into()))?;
203 |     let subreddit = subreddit_match
204 |         .as_str()
205 |         .to_string()
206 |         .replace("/r/", "")
207 |         .replace("r/", "");
208 |     let rest = &input[(subreddit_match.end())..];
209 | 
210 |     let limit: Option<u32> = LIMIT_RE
211 |         .captures(rest)
212 |         .and_then(|caps| caps.get(1))
213 |         .and_then(|m| m.as_str().parse().ok());
214 | 
215 |     let time = Ok(TIME_RE.captures(rest))
216 |         .map(|o| o.and_then(|caps| caps.get(1)))
217 |         .and_then(|o| match o {
218 |             Some(m) => m
219 |                 .as_str()
220 |                 .parse::<TopPostsTimePeriod>()
221 |                 .map(Some)
222 |                 .map_err(|e| ParseError::IncorrectFormat(e.into())),
223 |             None => Ok(None),
224 |         })?;
225 | 
226 |     let filter = Ok(FILTER_RE.captures(rest))
227 |         .map(|o| o.and_then(|caps| caps.get(1)))
228 |         .and_then(|o| match o {
229 |             Some(m) => m
230 |                 .as_str()
231 |                 .parse::<PostType>()
232 |                 .map(Some)
233 |                 .map_err(|e| ParseError::IncorrectFormat(e.into())),
234 |             None => Ok(None),
235 |         })?;
236 | 
237 |     let args = SubscriptionArgs {
238 |         subreddit,
239 |         limit,
240 |         time,
241 |         filter,
242 |     };
243 | 
244 |     Ok((args,))
245 | }
246 | 
247 | #[cfg(test)]
248 | mod tests {
249 |     use super::*;
250 | 
251 |     #[test]
252 |     fn test_parse_subscribe_message_only_subreddit() {
253 |         let args = parse_subscribe_message("AnimalsBeingJerks".to_string()).unwrap();
254 |         assert_eq!(
255 |             args.0,
256 |             SubscriptionArgs {
257 |                 subreddit: "AnimalsBeingJerks".to_string(),
258 |                 limit: None,
259 |                 time: None,
260 |                 filter: None,
261 |             },
262 |         )
263 |     }
264 | 
265 |     #[test]
266 |     fn test_parse_subscribe_message_strips_prefix() {
267 |         let args = parse_subscribe_message("r/AnimalsBeingJerks".to_string()).unwrap();
268 |         assert_eq!(
269 |             args.0,
270 |             SubscriptionArgs {
271 |                 subreddit: "AnimalsBeingJerks".to_string(),
272 |                 limit: None,
273 |                 time: None,
274 |                 filter: None,
275 |             },
276 |         );
277 | 
278 |         let args = parse_subscribe_message("/r/AnimalsBeingJerks".to_string()).unwrap();
279 |         assert_eq!(
280 |             args.0,
281 |             SubscriptionArgs {
282 |                 subreddit: "AnimalsBeingJerks".to_string(),
283 |                 limit: None,
284 |                 time: None,
285 |                 filter: None,
286 |             },
287 |         )
288 |     }
289 | 
290 |     #[test]
291 |     fn test_parse_subscribe_message() {
292 |         let args =
293 |             parse_subscribe_message("AnimalsBeingJerks limit=5 time=week filter=video".to_string())
294 |                 .unwrap();
295 |         assert_eq!(
296 |             args.0,
297 |             SubscriptionArgs {
298 |                 subreddit: "AnimalsBeingJerks".to_string(),
299 |                 limit: Some(5),
300 |                 time: Some(TopPostsTimePeriod::Week),
301 |                 filter: Some(PostType::Video),
302 |             },
303 |         )
304 |     }
305 | }
306 | 


--------------------------------------------------------------------------------
/src/db.rs:
--------------------------------------------------------------------------------
  1 | use crate::{config::*, reddit::*, types::*};
  2 | use anyhow::{Context, Result};
  3 | use rusqlite::types::{FromSql, FromSqlError, FromSqlResult, ToSql, ToSqlOutput, Value, ValueRef};
  4 | use rusqlite::{named_params, Connection, Row};
  5 | use rusqlite_migration::{Migrations, M};
  6 | use std::convert::TryFrom;
  7 | use std::path::Path;
  8 | use std::str::FromStr;
  9 | use std::string::ToString;
 10 | 
 11 | const MIGRATIONS: &[&str] = &[
 12 |     "
 13 |     create table post(
 14 |         post_id     text not null,
 15 |         chat_id     integer not null,
 16 |         subreddit   text not null,
 17 |         seen_at     text not null,
 18 |         primary key (post_id, chat_id)
 19 |     ) strict;
 20 |     ",
 21 |     "
 22 |     create table subscription(
 23 |         chat_id     integer not null,
 24 |         subreddit   text not null,
 25 |         created_at  text not null,
 26 |         post_limit  integer,
 27 |         time        text,
 28 |         filter      text,
 29 |         primary key (subreddit, chat_id)
 30 |     ) strict;
 31 | ",
 32 | ];
 33 | 
 34 | #[derive(Debug)]
 35 | pub struct Database {
 36 |     pub conn: Connection,
 37 | }
 38 | 
 39 | impl Database {
 40 |     pub fn open(config: &Config) -> Result<Self> {
 41 |         let conn = Self::get_conn(&config.db_path).context("error connecting to database")?;
 42 |         conn.pragma_update(None, "foreign_keys", "ON")?;
 43 |         Ok(Database { conn })
 44 |     }
 45 | 
 46 |     #[cfg(test)]
 47 |     fn get_conn(_db_path: &Path) -> Result<Connection, rusqlite::Error> {
 48 |         Connection::open_in_memory()
 49 |     }
 50 | 
 51 |     #[cfg(not(test))]
 52 |     fn get_conn(db_path: &Path) -> Result<Connection, rusqlite::Error> {
 53 |         Connection::open(db_path)
 54 |     }
 55 | 
 56 |     pub fn migrate(&mut self) -> Result<(), rusqlite_migration::Error> {
 57 |         let migrations = MIGRATIONS.iter().map(|e| M::up(e)).collect();
 58 |         Migrations::new(migrations).to_latest(&mut self.conn)
 59 |     }
 60 | 
 61 |     pub fn mark_post_seen(&self, chat_id: i64, post: &Post) -> Result<()> {
 62 |         let mut stmt = self.conn.prepare(
 63 |             "
 64 |             insert into post (post_id, chat_id, subreddit, seen_at)
 65 |             values (:post_id, :chat_id, :subreddit, :seen_at)
 66 |             ",
 67 |         )?;
 68 |         stmt.execute(named_params! {
 69 |             ":post_id": post.id,
 70 |             ":chat_id": chat_id,
 71 |             ":subreddit": &post.subreddit,
 72 |             ":seen_at": chrono::Utc::now()
 73 |         })
 74 |         .context("could not mark post seen")
 75 |         .map(|_| ())
 76 |     }
 77 | 
 78 |     pub fn is_post_seen(&self, chat_id: i64, post: &Post) -> Result<bool> {
 79 |         let mut stmt = self.conn.prepare(
 80 |             "
 81 |             select exists(
 82 |                 select 1 
 83 |                   from post
 84 |                  where post_id = :post_id and chat_id = :chat_id
 85 |             );
 86 |             ",
 87 |         )?;
 88 | 
 89 |         stmt.query_row(
 90 |             named_params! {
 91 |                 ":post_id": post.id,
 92 |                 ":chat_id": chat_id
 93 |             },
 94 |             |row| row.get(0),
 95 |         )
 96 |         .map_err(anyhow::Error::from)
 97 |     }
 98 | 
 99 |     pub fn existing_posts_for_subreddit(&self, chat_id: i64, subreddit: &str) -> Result<bool> {
100 |         let mut stmt = self.conn.prepare(
101 |             "
102 |             select exists(
103 |                 select 1
104 |                   from post
105 |                  where chat_id = :chat_id and subreddit = :subreddit
106 |             );
107 |             ",
108 |         )?;
109 | 
110 |         stmt.query_row(
111 |             named_params! {
112 |                 ":chat_id": chat_id,
113 |                 ":subreddit": subreddit,
114 |             },
115 |             |row| row.get(0),
116 |         )
117 |         .map_err(anyhow::Error::from)
118 |     }
119 | 
120 |     pub fn subscribe(&self, chat_id: i64, args: &SubscriptionArgs) -> Result<()> {
121 |         let mut stmt = self.conn.prepare(
122 |             "
123 |             insert into subscription (chat_id, subreddit, post_limit, time, filter, created_at)
124 |             values (:chat_id, :subreddit, :limit, :time, :filter, :created_at)
125 |             ",
126 |         )?;
127 |         stmt.execute(named_params! {
128 |             ":chat_id": chat_id,
129 |             ":subreddit": args.subreddit,
130 |             ":limit": args.limit,
131 |             ":time": args.time,
132 |             ":filter": args.filter,
133 |             ":created_at": chrono::Utc::now()
134 |         })
135 |         .context("could not add subscription")?;
136 |         Ok(())
137 |     }
138 | 
139 |     pub fn unsubscribe(&self, chat_id: i64, subreddit: &str) -> Result<String> {
140 |         let mut stmt = self.conn.prepare(
141 |             "
142 |             delete from subscription
143 |             where chat_id = :chat_id and subreddit LIKE :subreddit
144 |             returning subreddit
145 |             ",
146 |         )?;
147 |         let deleted_subreddit: String = stmt
148 |             .query_row(
149 |                 named_params! {
150 |                     ":chat_id": chat_id,
151 |                     ":subreddit": subreddit,
152 |                 },
153 |                 |row| row.get("subreddit"),
154 |             )
155 |             .context("could not delete subscription")?;
156 | 
157 |         // Delete posts so that if subreddit is subscribed to later, the first posts seen won't be
158 |         // considered new.
159 |         let mut stmt = self.conn.prepare(
160 |             "
161 |             delete from post
162 |             where chat_id = :chat_id and subreddit = :subreddit
163 |             ",
164 |         )?;
165 |         stmt.execute(named_params! {
166 |             ":chat_id": chat_id,
167 |             ":subreddit": deleted_subreddit,
168 |         })
169 |         .context("could not delete posts")?;
170 | 
171 |         Ok(deleted_subreddit)
172 |     }
173 | 
174 |     #[allow(dead_code)]
175 |     pub fn get_subscriptions_for_chat(&self, chat_id: i64) -> Result<Vec<Subscription>> {
176 |         let mut stmt = self.conn.prepare(
177 |             "
178 |             select chat_id, subreddit, post_limit, time, filter, created_at
179 |             from subscription
180 |             where chat_id = ?
181 |             ",
182 |         )?;
183 | 
184 |         let subs = stmt
185 |             .query_map([chat_id], |row| Subscription::try_from(row))?
186 |             .collect::<Result<Vec<_>, rusqlite::Error>>()?;
187 | 
188 |         Ok(subs)
189 |     }
190 | 
191 |     pub fn get_all_subscriptions(&self) -> Result<Vec<Subscription>> {
192 |         let mut stmt = self.conn.prepare(
193 |             "
194 |             select chat_id, subreddit, post_limit, time, filter, created_at
195 |             from subscription
196 |             ",
197 |         )?;
198 | 
199 |         let subs = stmt
200 |             .query_map([], |row| Subscription::try_from(row))?
201 |             .collect::<Result<Vec<_>, rusqlite::Error>>()?;
202 | 
203 |         Ok(subs)
204 |     }
205 | }
206 | 
207 | impl ToSql for TopPostsTimePeriod {
208 |     fn to_sql(&self) -> Result<rusqlite::types::ToSqlOutput, rusqlite::Error> {
209 |         Ok(ToSqlOutput::Owned(Value::Text(self.to_string())))
210 |     }
211 | }
212 | 
213 | impl ToSql for PostType {
214 |     fn to_sql(&self) -> Result<rusqlite::types::ToSqlOutput, rusqlite::Error> {
215 |         Ok(ToSqlOutput::Owned(Value::Text(self.to_string())))
216 |     }
217 | }
218 | 
219 | impl FromSql for TopPostsTimePeriod {
220 |     fn column_result(value: ValueRef) -> FromSqlResult<TopPostsTimePeriod> {
221 |         let str = String::column_result(value)?;
222 |         TopPostsTimePeriod::from_str(&str).map_err(|e| FromSqlError::Other(From::from(e)))
223 |     }
224 | }
225 | 
226 | impl FromSql for PostType {
227 |     fn column_result(value: ValueRef) -> FromSqlResult<PostType> {
228 |         let str = String::column_result(value)?;
229 |         PostType::from_str(&str).map_err(|e| FromSqlError::Other(From::from(e)))
230 |     }
231 | }
232 | 
233 | impl TryFrom<&Row<'_>> for Subscription {
234 |     type Error = rusqlite::Error;
235 | 
236 |     fn try_from(row: &Row<'_>) -> Result<Self, Self::Error> {
237 |         Ok(Self {
238 |             subreddit: row.get_unwrap("subreddit"),
239 |             chat_id: row.get_unwrap("chat_id"),
240 |             limit: row.get_unwrap("post_limit"),
241 |             time: row.get_unwrap("time"),
242 |             filter: row.get_unwrap("filter"),
243 |         })
244 |     }
245 | }
246 | 
247 | #[cfg(test)]
248 | mod tests {
249 |     use super::*;
250 |     use crate::reddit::PostType;
251 | 
252 |     #[test]
253 |     fn test_db() {
254 |         let config = Config::default();
255 |         let mut db = Database::open(&config).unwrap();
256 |         db.migrate().unwrap();
257 |         let post = Post {
258 |             id: "v6nu75".into(),
259 |             created: 1654581100.0,
260 |             post_hint: Some("link".into()),
261 |             subreddit: "absoluteunit".into(),
262 |             title: "Tipping a cow to trim its hooves".into(),
263 |             is_self: false,
264 |             is_video: false,
265 |             is_gallery: Some(false),
266 |             gallery_data: None,
267 |             media_metadata: None,
268 |             ups: 469,
269 |             permalink: "/r/absoluteunit/comments/v6nu75/tipping_a_cow_to_trim_its_hooves/".into(),
270 |             url: "https://i.imgur.com/Zt6f5mB.gifv".into(),
271 |             post_type: PostType::Video,
272 |             crosspost_parent_list: None,
273 |         };
274 | 
275 |         assert!(!db.existing_posts_for_subreddit(1, "absoluteunit").unwrap());
276 |         db.mark_post_seen(1, &post).unwrap();
277 |         assert!(db.is_post_seen(1, &post).unwrap());
278 |         assert!(db.existing_posts_for_subreddit(1, "absoluteunit").unwrap());
279 |     }
280 | 
281 |     #[test]
282 |     fn test_db_subscribe() {
283 |         let config = Config::default();
284 |         let mut db = Database::open(&config).unwrap();
285 |         db.migrate().unwrap();
286 |         let subscription_args = SubscriptionArgs {
287 |             subreddit: "test".to_string(),
288 |             limit: Some(1),
289 |             time: Some(TopPostsTimePeriod::Week),
290 |             filter: Some(PostType::Video),
291 |         };
292 |         db.subscribe(1, &subscription_args).unwrap();
293 | 
294 |         let subs = db.get_subscriptions_for_chat(1).unwrap();
295 |         assert_eq!(
296 |             subs,
297 |             vec![Subscription {
298 |                 chat_id: 1,
299 |                 subreddit: "test".to_string(),
300 |                 limit: Some(1),
301 |                 time: Some(TopPostsTimePeriod::Week),
302 |                 filter: Some(PostType::Video),
303 |             }]
304 |         );
305 |     }
306 | 
307 |     #[test]
308 |     fn test_db_unsubscribe() {
309 |         let config = Config::default();
310 |         let mut db = Database::open(&config).unwrap();
311 |         db.migrate().unwrap();
312 |         let subscription_args = SubscriptionArgs {
313 |             subreddit: "test".to_string(),
314 |             limit: Some(1),
315 |             time: Some(TopPostsTimePeriod::Week),
316 |             filter: Some(PostType::Video),
317 |         };
318 |         db.subscribe(1, &subscription_args).unwrap();
319 |         let subs = db.get_subscriptions_for_chat(1).unwrap();
320 |         assert_eq!(subs.len(), 1);
321 |         let deleted = db.unsubscribe(1, "test").unwrap();
322 |         assert_eq!(deleted, "test");
323 |         let subs = db.get_subscriptions_for_chat(1).unwrap();
324 |         assert_eq!(subs, vec![]);
325 |     }
326 | 
327 |     #[test]
328 |     fn test_db_unsubscribe_deletes_posts() {
329 |         let config = Config::default();
330 |         let mut db = Database::open(&config).unwrap();
331 |         db.migrate().unwrap();
332 |         let subscription_args = SubscriptionArgs {
333 |             subreddit: "test".to_string(),
334 |             limit: Some(1),
335 |             time: Some(TopPostsTimePeriod::Week),
336 |             filter: Some(PostType::Video),
337 |         };
338 |         db.subscribe(1, &subscription_args).unwrap();
339 |         let post = Post {
340 |             id: "v6nu75".into(),
341 |             created: 1654581100.0,
342 |             post_hint: Some("link".into()),
343 |             subreddit: "test".into(),
344 |             title: "Tipping a cow to trim its hooves".into(),
345 |             is_self: false,
346 |             is_gallery: Some(false),
347 |             is_video: false,
348 |             gallery_data: None,
349 |             media_metadata: None,
350 |             ups: 469,
351 |             permalink: "/r/test/comments/v6nu75/tipping_a_cow_to_trim_its_hooves/".into(),
352 |             url: "https://i.imgur.com/Zt6f5mB.gifv".into(),
353 |             post_type: PostType::Video,
354 |             crosspost_parent_list: None,
355 |         };
356 |         db.mark_post_seen(1, &post).unwrap();
357 |         assert!(db.is_post_seen(1, &post).unwrap());
358 |         db.unsubscribe(1, "test").unwrap();
359 |         assert!(!db.is_post_seen(1, &post).unwrap());
360 |     }
361 | }
362 | 


--------------------------------------------------------------------------------
/src/main.rs:
--------------------------------------------------------------------------------
  1 | use crate::{download::*, types::*};
  2 | use anyhow::{Context, Result};
  3 | use log::*;
  4 | use reddit::{PostType, TopPostsTimePeriod};
  5 | use signal_hook::{
  6 |     consts::signal::{SIGINT, SIGTERM},
  7 |     iterator::Signals,
  8 | };
  9 | use std::collections::HashMap;
 10 | use std::string::ToString;
 11 | use std::{
 12 |     borrow::Cow,
 13 |     path::PathBuf,
 14 |     sync::{
 15 |         atomic::{AtomicBool, Ordering},
 16 |         Arc,
 17 |     },
 18 |     time::Duration,
 19 | };
 20 | use teloxide::types::InputFile;
 21 | use teloxide::{
 22 |     payloads::{SendMessageSetters, SendPhotoSetters, SendVideoSetters},
 23 |     types::InputMediaPhoto,
 24 | };
 25 | use teloxide::{prelude::*, types::InputMedia};
 26 | use tempdir::TempDir;
 27 | use tokio::sync::broadcast;
 28 | 
 29 | mod args;
 30 | mod bot;
 31 | mod config;
 32 | mod db;
 33 | mod download;
 34 | mod messages;
 35 | mod reddit;
 36 | mod types;
 37 | mod ytdlp;
 38 | 
 39 | const PKG_NAME: &str = env!("CARGO_PKG_NAME");
 40 | 
 41 | #[tokio::main]
 42 | async fn main() -> Result<()> {
 43 |     env_logger::init();
 44 |     let config = Arc::new(config::read_config());
 45 |     info!("starting with config: {config:#?}");
 46 |     let mut db = db::Database::open(&config)?;
 47 |     db.migrate()?;
 48 |     drop(db);
 49 | 
 50 |     let (shutdown_tx, mut shutdown_rx) = broadcast::channel::<()>(1);
 51 |     let shutdown = Arc::new(AtomicBool::new(false));
 52 |     let bot = bot::MyBot::new(config.clone()).await?;
 53 | 
 54 |     // Any arguments are for things that help with debugging and development
 55 |     // Not optimized for usability.
 56 |     //
 57 |     // Usage: tgreddit --debug-post <linkid>                    => Fetch post and print deserialized post
 58 |     //        tgreddit --debug-post <linkid> --chat-id <chatid> => Also send to telegram
 59 |     let opts = args::parse_args();
 60 |     if let Some(post_id) = opts.opt_str("debug-post") {
 61 |         let post = reddit::get_link(&post_id).await.unwrap();
 62 |         info!("{:#?}", post);
 63 |         if let Some(chat_id) = opts.opt_str("chat-id") {
 64 |             return handle_new_post(&config, &bot.tg, chat_id.parse().unwrap(), &post).await;
 65 |         }
 66 |         return Ok(());
 67 |     }
 68 | 
 69 |     let sub_check_loop_handle = {
 70 |         let shutdown = shutdown.clone();
 71 |         let tg = bot.tg.clone();
 72 |         tokio::task::spawn(async move {
 73 |             while !shutdown.load(Ordering::Acquire) {
 74 |                 check_new_posts(&config, &tg).await.unwrap_or_else(|err| {
 75 |                     error!("failed to check for new posts: {err}");
 76 |                 });
 77 | 
 78 |                 tokio::select! {
 79 |                    _ = tokio::time::sleep(Duration::from_secs(config.check_interval_secs)) => {}
 80 |                    _ = shutdown_rx.recv() => {
 81 |                        break
 82 |                    }
 83 |                 }
 84 |             }
 85 |         })
 86 |     };
 87 |     let (bot_handle, bot_shutdown_token) = bot.spawn();
 88 | 
 89 |     {
 90 |         let shutdown = shutdown.clone();
 91 |         std::thread::spawn(move || {
 92 |             let mut forward_signals =
 93 |                 Signals::new([SIGINT, SIGTERM]).expect("unable to watch for signals");
 94 | 
 95 |             for signal in forward_signals.forever() {
 96 |                 info!("got signal {signal}, shutting down...");
 97 |                 shutdown.swap(true, Ordering::Relaxed);
 98 |                 let _res = bot_shutdown_token.shutdown();
 99 |                 let _res = shutdown_tx.send(()).unwrap_or_else(|_| {
100 |                     // Makes the second Ctrl-C exit instantly
101 |                     std::process::exit(0);
102 |                 });
103 |             }
104 |         });
105 |     }
106 | 
107 |     if let Err(err) = tokio::try_join!(bot_handle, sub_check_loop_handle) {
108 |         panic!("{err}")
109 |     }
110 | 
111 |     Ok(())
112 | }
113 | 
114 | async fn handle_new_video_post(
115 |     config: &config::Config,
116 |     tg: &Bot,
117 |     chat_id: i64,
118 |     post: &reddit::Post,
119 | ) -> Result<()> {
120 |     // The temporary directory will be deleted when _tmp_dir is dropped
121 |     let (video, _tmp_dir) = tokio::task::block_in_place(|| ytdlp::download(&post.url))?;
122 |     info!("got a video: {video:?}");
123 |     let caption = messages::format_media_caption_html(post, config.links_base_url.as_deref());
124 |     tg.send_video(ChatId(chat_id), InputFile::file(&video.path))
125 |         .parse_mode(teloxide::types::ParseMode::Html)
126 |         .caption(&caption)
127 |         .height(video.height.into())
128 |         .width(video.width.into())
129 |         .await?;
130 |     info!(
131 |         "video uploaded post_id={} chat_id={chat_id} video={video:?}",
132 |         post.id
133 |     );
134 |     Ok(())
135 | }
136 | 
137 | async fn handle_new_image_post(
138 |     config: &config::Config,
139 |     tg: &Bot,
140 |     chat_id: i64,
141 |     post: &reddit::Post,
142 | ) -> Result<()> {
143 |     match download_url_to_tmp(&post.url).await {
144 |         Ok((path, _tmp_dir)) => {
145 |             // path will be deleted when _tmp_dir when goes out of scope
146 |             let caption =
147 |                 messages::format_media_caption_html(post, config.links_base_url.as_deref());
148 |             tg.send_photo(ChatId(chat_id), InputFile::file(path))
149 |                 .parse_mode(teloxide::types::ParseMode::Html)
150 |                 .caption(&caption)
151 |                 .await?;
152 |             info!("image uploaded post_id={} chat_id={chat_id}", post.id);
153 |             Ok(())
154 |         }
155 |         Err(e) => {
156 |             error!("failed to download image: {e}");
157 |             Err(e)
158 |         }
159 |     }
160 | }
161 | 
162 | async fn handle_new_link_post(
163 |     config: &config::Config,
164 |     tg: &Bot,
165 |     chat_id: i64,
166 |     post: &reddit::Post,
167 | ) -> Result<()> {
168 |     let message_html = messages::format_link_message_html(post, config.links_base_url.as_deref());
169 |     tg.send_message(ChatId(chat_id), message_html)
170 |         .parse_mode(teloxide::types::ParseMode::Html)
171 |         .disable_web_page_preview(false)
172 |         .await?;
173 |     info!("message sent post_id={} chat_id={chat_id}", post.id);
174 |     Ok(())
175 | }
176 | 
177 | async fn handle_new_self_post(
178 |     config: &config::Config,
179 |     tg: &Bot,
180 |     chat_id: i64,
181 |     post: &reddit::Post,
182 | ) -> Result<()> {
183 |     let message_html = messages::format_media_caption_html(post, config.links_base_url.as_deref());
184 |     tg.send_message(ChatId(chat_id), message_html)
185 |         .parse_mode(teloxide::types::ParseMode::Html)
186 |         .disable_web_page_preview(true)
187 |         .await?;
188 |     info!("message sent post_id={} chat_id={chat_id}", post.id);
189 |     Ok(())
190 | }
191 | 
192 | async fn download_gallery(post: &reddit::Post) -> Result<HashMap<String, (PathBuf, TempDir)>> {
193 |     let media_metadata_map = post
194 |         .media_metadata
195 |         .as_ref()
196 |         .expect("expected media_metadata to exist in gallery post");
197 | 
198 |     let mut map: HashMap<String, (PathBuf, TempDir)> = HashMap::new();
199 |     for (id, media_metadata) in media_metadata_map {
200 |         let s = &media_metadata.s;
201 |         let url = &s.url.replace("&amp;", "&");
202 |         info!("got media id={id} x={} y={} url={}", &s.x, &s.y, url);
203 |         map.insert(id.to_string(), download_url_to_tmp(url).await?);
204 |     }
205 | 
206 |     Ok(map)
207 | }
208 | 
209 | async fn handle_new_gallery_post(
210 |     config: &config::Config,
211 |     tg: &Bot,
212 |     chat_id: i64,
213 |     post: &reddit::Post,
214 | ) -> Result<()> {
215 |     // post.gallery_data is an array that describes the order of photos in the gallery, while
216 |     // post.media_metadata is a map that contains the URL for each photo
217 |     let gallery_data_items = &post
218 |         .gallery_data
219 |         .as_ref()
220 |         .expect("expected media_metadata to exist in gallery post")
221 |         .items;
222 |     let gallery_files_map = download_gallery(post).await?;
223 |     let mut media_group = vec![];
224 |     let mut first = true;
225 | 
226 |     for item in gallery_data_items {
227 |         let file = gallery_files_map.get(&item.media_id);
228 |         match file {
229 |             Some((image_path, _tempdir)) => {
230 |                 let mut input_media_photo = InputMediaPhoto::new(InputFile::file(image_path));
231 |                 // The first InputMediaPhoto in the vector needs to contain the caption and parse_mode;
232 |                 if first {
233 |                     let caption =
234 |                         messages::format_media_caption_html(post, config.links_base_url.as_deref());
235 |                     input_media_photo = input_media_photo
236 |                         .caption(&caption)
237 |                         .parse_mode(teloxide::types::ParseMode::Html);
238 |                     first = false;
239 |                 }
240 | 
241 |                 media_group.push(InputMedia::Photo(input_media_photo))
242 |             }
243 |             None => {
244 |                 error!("could not find downloaded image for gallery data item: {item:?}");
245 |             }
246 |         }
247 |     }
248 | 
249 |     tg.send_media_group(ChatId(chat_id), media_group).await?;
250 |     info!("gallery uploaded post_id={} chat_id={chat_id}", post.id);
251 | 
252 |     Ok(())
253 | }
254 | 
255 | async fn handle_new_post(
256 |     config: &config::Config,
257 |     tg: &Bot,
258 |     chat_id: i64,
259 |     post: &reddit::Post,
260 | ) -> Result<()> {
261 |     info!("got new {post:#?}");
262 |     let mut post = Cow::Borrowed(post);
263 | 
264 |     // Sometimes post_hint is not in top list response but exists when getting the link directly,
265 |     // but not always
266 |     // TODO: It appears that post with is_gallery=true will never have post_hint set
267 |     if post.post_hint.is_none() {
268 |         info!("post missing post_hint, getting like directly");
269 |         post = Cow::Owned(reddit::get_link(&post.id).await.unwrap());
270 |     }
271 | 
272 |     match post.post_type {
273 |         reddit::PostType::Image => handle_new_image_post(config, tg, chat_id, &post).await,
274 |         reddit::PostType::Video => handle_new_video_post(config, tg, chat_id, &post).await,
275 |         reddit::PostType::Link => handle_new_link_post(config, tg, chat_id, &post).await,
276 |         reddit::PostType::SelfText => handle_new_self_post(config, tg, chat_id, &post).await,
277 |         reddit::PostType::Gallery => handle_new_gallery_post(config, tg, chat_id, &post).await,
278 |         // /r/bestof posts have no characteristics like post_hint that could be used to
279 |         // determine them as a type of Link; as a workaround, post Unknown post types the same way
280 |         // as a link
281 |         reddit::PostType::Unknown => {
282 |             warn!("unknown post type, post={post:?}");
283 |             handle_new_link_post(config, tg, chat_id, &post).await
284 |         }
285 |     }
286 | }
287 | 
288 | async fn check_post_newness(
289 |     config: &config::Config,
290 |     tg: &Bot,
291 |     chat_id: i64,
292 |     filter: Option<reddit::PostType>,
293 |     post: &reddit::Post,
294 |     only_mark_seen: bool,
295 | ) -> Result<()> {
296 |     let db = db::Database::open(config)?;
297 |     if filter.is_some() && filter.as_ref() != Some(&post.post_type) {
298 |         debug!("filter set and post does not match filter, skipping");
299 |         return Ok(());
300 |     }
301 | 
302 |     if db
303 |         .is_post_seen(chat_id, post)
304 |         .expect("failed to query if post is seen")
305 |     {
306 |         debug!("post already seen, skipping...");
307 |         return Ok(());
308 |     }
309 | 
310 |     if !only_mark_seen {
311 |         // Intentionally marking post as seen if handling it fails. It's preferable to not have it
312 |         // fail continuously.
313 |         if let Err(e) = handle_new_post(config, tg, chat_id, post).await {
314 |             error!("failed to handle new post: {e}");
315 |         }
316 |     }
317 | 
318 |     db.mark_post_seen(chat_id, post)?;
319 |     info!("marked post seen: {}", post.id);
320 | 
321 |     Ok(())
322 | }
323 | 
324 | async fn check_new_posts(config: &config::Config, tg: &Bot) -> Result<()> {
325 |     info!("checking subscriptions for new posts");
326 |     let db = db::Database::open(config)?;
327 |     let subs = db.get_all_subscriptions()?;
328 |     for sub in subs {
329 |         check_new_posts_for_subscription(config, tg, &sub)
330 |             .await
331 |             .unwrap_or_else(|err| {
332 |                 error!("failed to check subscription for new posts: {err}");
333 |             });
334 |     }
335 | 
336 |     Ok(())
337 | }
338 | 
339 | async fn check_new_posts_for_subscription(
340 |     config: &config::Config,
341 |     tg: &Bot,
342 |     sub: &Subscription,
343 | ) -> Result<()> {
344 |     let db = db::Database::open(config)?;
345 |     let subreddit = &sub.subreddit;
346 |     let limit = sub
347 |         .limit
348 |         .or(config.default_limit)
349 |         .unwrap_or(config::DEFAULT_LIMIT);
350 |     let time = sub
351 |         .time
352 |         .or(config.default_time)
353 |         .unwrap_or(config::DEFAULT_TIME_PERIOD);
354 |     let filter = sub.filter.or(config.default_filter);
355 |     let chat_id = sub.chat_id;
356 |     info!(
357 |         "checking subreddit /r/{subreddit} for new posts for user {chat_id}",
358 |         subreddit = subreddit,
359 |         chat_id = chat_id
360 |     );
361 | 
362 |     match reddit::get_subreddit_top_posts(subreddit, limit, &time).await {
363 |         Ok(posts) => {
364 |             debug!("got {} post(s) for subreddit /r/{}", posts.len(), subreddit);
365 | 
366 |             // First run should not send anything to telegram but the post should be marked
367 |             // as seen, unless skip_initial_send is enabled
368 |             let is_new_subreddit = !db
369 |                 .existing_posts_for_subreddit(chat_id, subreddit)
370 |                 .context("failed to query if subreddit has existing posts")?;
371 |             let only_mark_seen = is_new_subreddit && config.skip_initial_send;
372 | 
373 |             for post in posts {
374 |                 debug!("got {post:?}");
375 |                 check_post_newness(config, tg, chat_id, filter, &post, only_mark_seen)
376 |                     .await
377 |                     .unwrap_or_else(|err| {
378 |                         error!("failed to check post newness: {err}");
379 |                     });
380 |             }
381 |         }
382 |         Err(e) => {
383 |             error!("failed to get posts for {}: {e}", subreddit)
384 |         }
385 |     };
386 | 
387 |     Ok(())
388 | }
389 | 


--------------------------------------------------------------------------------
/Cargo.lock:
--------------------------------------------------------------------------------
   1 | # This file is automatically @generated by Cargo.
   2 | # It is not intended for manual editing.
   3 | version = 3
   4 | 
   5 | [[package]]
   6 | name = "addr2line"
   7 | version = "0.21.0"
   8 | source = "registry+https://github.com/rust-lang/crates.io-index"
   9 | checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
  10 | dependencies = [
  11 |  "gimli",
  12 | ]
  13 | 
  14 | [[package]]
  15 | name = "adler"
  16 | version = "1.0.2"
  17 | source = "registry+https://github.com/rust-lang/crates.io-index"
  18 | checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
  19 | 
  20 | [[package]]
  21 | name = "ahash"
  22 | version = "0.8.3"
  23 | source = "registry+https://github.com/rust-lang/crates.io-index"
  24 | checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
  25 | dependencies = [
  26 |  "cfg-if",
  27 |  "once_cell",
  28 |  "version_check",
  29 | ]
  30 | 
  31 | [[package]]
  32 | name = "aho-corasick"
  33 | version = "1.0.4"
  34 | source = "registry+https://github.com/rust-lang/crates.io-index"
  35 | checksum = "6748e8def348ed4d14996fa801f4122cd763fff530258cdc03f64b25f89d3a5a"
  36 | dependencies = [
  37 |  "memchr",
  38 | ]
  39 | 
  40 | [[package]]
  41 | name = "allocator-api2"
  42 | version = "0.2.16"
  43 | source = "registry+https://github.com/rust-lang/crates.io-index"
  44 | checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
  45 | 
  46 | [[package]]
  47 | name = "android-tzdata"
  48 | version = "0.1.1"
  49 | source = "registry+https://github.com/rust-lang/crates.io-index"
  50 | checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
  51 | 
  52 | [[package]]
  53 | name = "android_system_properties"
  54 | version = "0.1.5"
  55 | source = "registry+https://github.com/rust-lang/crates.io-index"
  56 | checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
  57 | dependencies = [
  58 |  "libc",
  59 | ]
  60 | 
  61 | [[package]]
  62 | name = "anyhow"
  63 | version = "1.0.75"
  64 | source = "registry+https://github.com/rust-lang/crates.io-index"
  65 | checksum = "a4668cab20f66d8d020e1fbc0ebe47217433c1b6c8f2040faf858554e394ace6"
  66 | 
  67 | [[package]]
  68 | name = "aquamarine"
  69 | version = "0.1.12"
  70 | source = "registry+https://github.com/rust-lang/crates.io-index"
  71 | checksum = "a941c39708478e8eea39243b5983f1c42d2717b3620ee91f4a52115fd02ac43f"
  72 | dependencies = [
  73 |  "itertools 0.9.0",
  74 |  "proc-macro-error",
  75 |  "proc-macro2",
  76 |  "quote",
  77 |  "syn 1.0.109",
  78 | ]
  79 | 
  80 | [[package]]
  81 | name = "atty"
  82 | version = "0.2.14"
  83 | source = "registry+https://github.com/rust-lang/crates.io-index"
  84 | checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8"
  85 | dependencies = [
  86 |  "hermit-abi 0.1.19",
  87 |  "libc",
  88 |  "winapi",
  89 | ]
  90 | 
  91 | [[package]]
  92 | name = "autocfg"
  93 | version = "1.1.0"
  94 | source = "registry+https://github.com/rust-lang/crates.io-index"
  95 | checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
  96 | 
  97 | [[package]]
  98 | name = "backtrace"
  99 | version = "0.3.69"
 100 | source = "registry+https://github.com/rust-lang/crates.io-index"
 101 | checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
 102 | dependencies = [
 103 |  "addr2line",
 104 |  "cc",
 105 |  "cfg-if",
 106 |  "libc",
 107 |  "miniz_oxide",
 108 |  "object",
 109 |  "rustc-demangle",
 110 | ]
 111 | 
 112 | [[package]]
 113 | name = "base64"
 114 | version = "0.21.2"
 115 | source = "registry+https://github.com/rust-lang/crates.io-index"
 116 | checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d"
 117 | 
 118 | [[package]]
 119 | name = "bitflags"
 120 | version = "1.3.2"
 121 | source = "registry+https://github.com/rust-lang/crates.io-index"
 122 | checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 123 | 
 124 | [[package]]
 125 | name = "bitflags"
 126 | version = "2.4.0"
 127 | source = "registry+https://github.com/rust-lang/crates.io-index"
 128 | checksum = "b4682ae6287fcf752ecaabbfcc7b6f9b72aa33933dc23a554d853aea8eea8635"
 129 | 
 130 | [[package]]
 131 | name = "bumpalo"
 132 | version = "3.13.0"
 133 | source = "registry+https://github.com/rust-lang/crates.io-index"
 134 | checksum = "a3e2c3daef883ecc1b5d58c15adae93470a91d425f3532ba1695849656af3fc1"
 135 | 
 136 | [[package]]
 137 | name = "bytes"
 138 | version = "1.4.0"
 139 | source = "registry+https://github.com/rust-lang/crates.io-index"
 140 | checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be"
 141 | 
 142 | [[package]]
 143 | name = "cc"
 144 | version = "1.0.83"
 145 | source = "registry+https://github.com/rust-lang/crates.io-index"
 146 | checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
 147 | dependencies = [
 148 |  "libc",
 149 | ]
 150 | 
 151 | [[package]]
 152 | name = "cfg-if"
 153 | version = "1.0.0"
 154 | source = "registry+https://github.com/rust-lang/crates.io-index"
 155 | checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 156 | 
 157 | [[package]]
 158 | name = "chrono"
 159 | version = "0.4.26"
 160 | source = "registry+https://github.com/rust-lang/crates.io-index"
 161 | checksum = "ec837a71355b28f6556dbd569b37b3f363091c0bd4b2e735674521b4c5fd9bc5"
 162 | dependencies = [
 163 |  "android-tzdata",
 164 |  "iana-time-zone",
 165 |  "js-sys",
 166 |  "num-traits",
 167 |  "time",
 168 |  "wasm-bindgen",
 169 |  "winapi",
 170 | ]
 171 | 
 172 | [[package]]
 173 | name = "convert_case"
 174 | version = "0.4.0"
 175 | source = "registry+https://github.com/rust-lang/crates.io-index"
 176 | checksum = "6245d59a3e82a7fc217c5828a6692dbc6dfb63a0c8c90495621f7b9d79704a0e"
 177 | 
 178 | [[package]]
 179 | name = "core-foundation"
 180 | version = "0.9.3"
 181 | source = "registry+https://github.com/rust-lang/crates.io-index"
 182 | checksum = "194a7a9e6de53fa55116934067c844d9d749312f75c6f6d0980e8c252f8c2146"
 183 | dependencies = [
 184 |  "core-foundation-sys",
 185 |  "libc",
 186 | ]
 187 | 
 188 | [[package]]
 189 | name = "core-foundation-sys"
 190 | version = "0.8.4"
 191 | source = "registry+https://github.com/rust-lang/crates.io-index"
 192 | checksum = "e496a50fda8aacccc86d7529e2c1e0892dbd0f898a6b5645b5561b89c3210efa"
 193 | 
 194 | [[package]]
 195 | name = "darling"
 196 | version = "0.13.4"
 197 | source = "registry+https://github.com/rust-lang/crates.io-index"
 198 | checksum = "a01d95850c592940db9b8194bc39f4bc0e89dee5c4265e4b1807c34a9aba453c"
 199 | dependencies = [
 200 |  "darling_core",
 201 |  "darling_macro",
 202 | ]
 203 | 
 204 | [[package]]
 205 | name = "darling_core"
 206 | version = "0.13.4"
 207 | source = "registry+https://github.com/rust-lang/crates.io-index"
 208 | checksum = "859d65a907b6852c9361e3185c862aae7fafd2887876799fa55f5f99dc40d610"
 209 | dependencies = [
 210 |  "fnv",
 211 |  "ident_case",
 212 |  "proc-macro2",
 213 |  "quote",
 214 |  "strsim",
 215 |  "syn 1.0.109",
 216 | ]
 217 | 
 218 | [[package]]
 219 | name = "darling_macro"
 220 | version = "0.13.4"
 221 | source = "registry+https://github.com/rust-lang/crates.io-index"
 222 | checksum = "9c972679f83bdf9c42bd905396b6c3588a843a17f0f16dfcfa3e2c5d57441835"
 223 | dependencies = [
 224 |  "darling_core",
 225 |  "quote",
 226 |  "syn 1.0.109",
 227 | ]
 228 | 
 229 | [[package]]
 230 | name = "derive_more"
 231 | version = "0.99.17"
 232 | source = "registry+https://github.com/rust-lang/crates.io-index"
 233 | checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321"
 234 | dependencies = [
 235 |  "convert_case",
 236 |  "proc-macro2",
 237 |  "quote",
 238 |  "rustc_version",
 239 |  "syn 1.0.109",
 240 | ]
 241 | 
 242 | [[package]]
 243 | name = "dptree"
 244 | version = "0.3.0"
 245 | source = "registry+https://github.com/rust-lang/crates.io-index"
 246 | checksum = "d81175dab5ec79c30e0576df2ed2c244e1721720c302000bb321b107e82e265c"
 247 | dependencies = [
 248 |  "futures",
 249 | ]
 250 | 
 251 | [[package]]
 252 | name = "duct"
 253 | version = "0.13.6"
 254 | source = "registry+https://github.com/rust-lang/crates.io-index"
 255 | checksum = "37ae3fc31835f74c2a7ceda3aeede378b0ae2e74c8f1c36559fcc9ae2a4e7d3e"
 256 | dependencies = [
 257 |  "libc",
 258 |  "once_cell",
 259 |  "os_pipe",
 260 |  "shared_child",
 261 | ]
 262 | 
 263 | [[package]]
 264 | name = "either"
 265 | version = "1.9.0"
 266 | source = "registry+https://github.com/rust-lang/crates.io-index"
 267 | checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
 268 | 
 269 | [[package]]
 270 | name = "encoding_rs"
 271 | version = "0.8.33"
 272 | source = "registry+https://github.com/rust-lang/crates.io-index"
 273 | checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
 274 | dependencies = [
 275 |  "cfg-if",
 276 | ]
 277 | 
 278 | [[package]]
 279 | name = "env_logger"
 280 | version = "0.9.3"
 281 | source = "registry+https://github.com/rust-lang/crates.io-index"
 282 | checksum = "a12e6657c4c97ebab115a42dcee77225f7f482cdd841cf7088c657a42e9e00e7"
 283 | dependencies = [
 284 |  "atty",
 285 |  "humantime",
 286 |  "log",
 287 |  "regex",
 288 |  "termcolor",
 289 | ]
 290 | 
 291 | [[package]]
 292 | name = "erasable"
 293 | version = "1.2.1"
 294 | source = "registry+https://github.com/rust-lang/crates.io-index"
 295 | checksum = "5f11890ce181d47a64e5d1eb4b6caba0e7bae911a356723740d058a5d0340b7d"
 296 | dependencies = [
 297 |  "autocfg",
 298 |  "scopeguard",
 299 | ]
 300 | 
 301 | [[package]]
 302 | name = "errno"
 303 | version = "0.3.2"
 304 | source = "registry+https://github.com/rust-lang/crates.io-index"
 305 | checksum = "6b30f669a7961ef1631673d2766cc92f52d64f7ef354d4fe0ddfd30ed52f0f4f"
 306 | dependencies = [
 307 |  "errno-dragonfly",
 308 |  "libc",
 309 |  "windows-sys",
 310 | ]
 311 | 
 312 | [[package]]
 313 | name = "errno-dragonfly"
 314 | version = "0.1.2"
 315 | source = "registry+https://github.com/rust-lang/crates.io-index"
 316 | checksum = "aa68f1b12764fab894d2755d2518754e71b4fd80ecfb822714a1206c2aab39bf"
 317 | dependencies = [
 318 |  "cc",
 319 |  "libc",
 320 | ]
 321 | 
 322 | [[package]]
 323 | name = "fallible-iterator"
 324 | version = "0.2.0"
 325 | source = "registry+https://github.com/rust-lang/crates.io-index"
 326 | checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7"
 327 | 
 328 | [[package]]
 329 | name = "fallible-streaming-iterator"
 330 | version = "0.1.9"
 331 | source = "registry+https://github.com/rust-lang/crates.io-index"
 332 | checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
 333 | 
 334 | [[package]]
 335 | name = "fastrand"
 336 | version = "2.0.0"
 337 | source = "registry+https://github.com/rust-lang/crates.io-index"
 338 | checksum = "6999dc1837253364c2ebb0704ba97994bd874e8f195d665c50b7548f6ea92764"
 339 | 
 340 | [[package]]
 341 | name = "fnv"
 342 | version = "1.0.7"
 343 | source = "registry+https://github.com/rust-lang/crates.io-index"
 344 | checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 345 | 
 346 | [[package]]
 347 | name = "foreign-types"
 348 | version = "0.3.2"
 349 | source = "registry+https://github.com/rust-lang/crates.io-index"
 350 | checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
 351 | dependencies = [
 352 |  "foreign-types-shared",
 353 | ]
 354 | 
 355 | [[package]]
 356 | name = "foreign-types-shared"
 357 | version = "0.1.1"
 358 | source = "registry+https://github.com/rust-lang/crates.io-index"
 359 | checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
 360 | 
 361 | [[package]]
 362 | name = "form_urlencoded"
 363 | version = "1.2.0"
 364 | source = "registry+https://github.com/rust-lang/crates.io-index"
 365 | checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
 366 | dependencies = [
 367 |  "percent-encoding",
 368 | ]
 369 | 
 370 | [[package]]
 371 | name = "fuchsia-cprng"
 372 | version = "0.1.1"
 373 | source = "registry+https://github.com/rust-lang/crates.io-index"
 374 | checksum = "a06f77d526c1a601b7c4cdd98f54b5eaabffc14d5f2f0296febdc7f357c6d3ba"
 375 | 
 376 | [[package]]
 377 | name = "futures"
 378 | version = "0.3.28"
 379 | source = "registry+https://github.com/rust-lang/crates.io-index"
 380 | checksum = "23342abe12aba583913b2e62f22225ff9c950774065e4bfb61a19cd9770fec40"
 381 | dependencies = [
 382 |  "futures-channel",
 383 |  "futures-core",
 384 |  "futures-executor",
 385 |  "futures-io",
 386 |  "futures-sink",
 387 |  "futures-task",
 388 |  "futures-util",
 389 | ]
 390 | 
 391 | [[package]]
 392 | name = "futures-channel"
 393 | version = "0.3.28"
 394 | source = "registry+https://github.com/rust-lang/crates.io-index"
 395 | checksum = "955518d47e09b25bbebc7a18df10b81f0c766eaf4c4f1cccef2fca5f2a4fb5f2"
 396 | dependencies = [
 397 |  "futures-core",
 398 |  "futures-sink",
 399 | ]
 400 | 
 401 | [[package]]
 402 | name = "futures-core"
 403 | version = "0.3.28"
 404 | source = "registry+https://github.com/rust-lang/crates.io-index"
 405 | checksum = "4bca583b7e26f571124fe5b7561d49cb2868d79116cfa0eefce955557c6fee8c"
 406 | 
 407 | [[package]]
 408 | name = "futures-executor"
 409 | version = "0.3.28"
 410 | source = "registry+https://github.com/rust-lang/crates.io-index"
 411 | checksum = "ccecee823288125bd88b4d7f565c9e58e41858e47ab72e8ea2d64e93624386e0"
 412 | dependencies = [
 413 |  "futures-core",
 414 |  "futures-task",
 415 |  "futures-util",
 416 | ]
 417 | 
 418 | [[package]]
 419 | name = "futures-io"
 420 | version = "0.3.28"
 421 | source = "registry+https://github.com/rust-lang/crates.io-index"
 422 | checksum = "4fff74096e71ed47f8e023204cfd0aa1289cd54ae5430a9523be060cdb849964"
 423 | 
 424 | [[package]]
 425 | name = "futures-macro"
 426 | version = "0.3.28"
 427 | source = "registry+https://github.com/rust-lang/crates.io-index"
 428 | checksum = "89ca545a94061b6365f2c7355b4b32bd20df3ff95f02da9329b34ccc3bd6ee72"
 429 | dependencies = [
 430 |  "proc-macro2",
 431 |  "quote",
 432 |  "syn 2.0.29",
 433 | ]
 434 | 
 435 | [[package]]
 436 | name = "futures-sink"
 437 | version = "0.3.28"
 438 | source = "registry+https://github.com/rust-lang/crates.io-index"
 439 | checksum = "f43be4fe21a13b9781a69afa4985b0f6ee0e1afab2c6f454a8cf30e2b2237b6e"
 440 | 
 441 | [[package]]
 442 | name = "futures-task"
 443 | version = "0.3.28"
 444 | source = "registry+https://github.com/rust-lang/crates.io-index"
 445 | checksum = "76d3d132be6c0e6aa1534069c705a74a5997a356c0dc2f86a47765e5617c5b65"
 446 | 
 447 | [[package]]
 448 | name = "futures-util"
 449 | version = "0.3.28"
 450 | source = "registry+https://github.com/rust-lang/crates.io-index"
 451 | checksum = "26b01e40b772d54cf6c6d721c1d1abd0647a0106a12ecaa1c186273392a69533"
 452 | dependencies = [
 453 |  "futures-channel",
 454 |  "futures-core",
 455 |  "futures-io",
 456 |  "futures-macro",
 457 |  "futures-sink",
 458 |  "futures-task",
 459 |  "memchr",
 460 |  "pin-project-lite",
 461 |  "pin-utils",
 462 |  "slab",
 463 | ]
 464 | 
 465 | [[package]]
 466 | name = "getopts"
 467 | version = "0.2.21"
 468 | source = "registry+https://github.com/rust-lang/crates.io-index"
 469 | checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
 470 | dependencies = [
 471 |  "unicode-width",
 472 | ]
 473 | 
 474 | [[package]]
 475 | name = "getrandom"
 476 | version = "0.2.10"
 477 | source = "registry+https://github.com/rust-lang/crates.io-index"
 478 | checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
 479 | dependencies = [
 480 |  "cfg-if",
 481 |  "libc",
 482 |  "wasi 0.11.0+wasi-snapshot-preview1",
 483 | ]
 484 | 
 485 | [[package]]
 486 | name = "gimli"
 487 | version = "0.28.0"
 488 | source = "registry+https://github.com/rust-lang/crates.io-index"
 489 | checksum = "6fb8d784f27acf97159b40fc4db5ecd8aa23b9ad5ef69cdd136d3bc80665f0c0"
 490 | 
 491 | [[package]]
 492 | name = "h2"
 493 | version = "0.3.21"
 494 | source = "registry+https://github.com/rust-lang/crates.io-index"
 495 | checksum = "91fc23aa11be92976ef4729127f1a74adf36d8436f7816b185d18df956790833"
 496 | dependencies = [
 497 |  "bytes",
 498 |  "fnv",
 499 |  "futures-core",
 500 |  "futures-sink",
 501 |  "futures-util",
 502 |  "http",
 503 |  "indexmap",
 504 |  "slab",
 505 |  "tokio",
 506 |  "tokio-util",
 507 |  "tracing",
 508 | ]
 509 | 
 510 | [[package]]
 511 | name = "hashbrown"
 512 | version = "0.12.3"
 513 | source = "registry+https://github.com/rust-lang/crates.io-index"
 514 | checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 515 | 
 516 | [[package]]
 517 | name = "hashbrown"
 518 | version = "0.14.0"
 519 | source = "registry+https://github.com/rust-lang/crates.io-index"
 520 | checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
 521 | dependencies = [
 522 |  "ahash",
 523 |  "allocator-api2",
 524 | ]
 525 | 
 526 | [[package]]
 527 | name = "hashlink"
 528 | version = "0.8.3"
 529 | source = "registry+https://github.com/rust-lang/crates.io-index"
 530 | checksum = "312f66718a2d7789ffef4f4b7b213138ed9f1eb3aa1d0d82fc99f88fb3ffd26f"
 531 | dependencies = [
 532 |  "hashbrown 0.14.0",
 533 | ]
 534 | 
 535 | [[package]]
 536 | name = "heck"
 537 | version = "0.4.1"
 538 | source = "registry+https://github.com/rust-lang/crates.io-index"
 539 | checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 540 | 
 541 | [[package]]
 542 | name = "hermit-abi"
 543 | version = "0.1.19"
 544 | source = "registry+https://github.com/rust-lang/crates.io-index"
 545 | checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 546 | dependencies = [
 547 |  "libc",
 548 | ]
 549 | 
 550 | [[package]]
 551 | name = "hermit-abi"
 552 | version = "0.3.2"
 553 | source = "registry+https://github.com/rust-lang/crates.io-index"
 554 | checksum = "443144c8cdadd93ebf52ddb4056d257f5b52c04d3c804e657d19eb73fc33668b"
 555 | 
 556 | [[package]]
 557 | name = "http"
 558 | version = "0.2.9"
 559 | source = "registry+https://github.com/rust-lang/crates.io-index"
 560 | checksum = "bd6effc99afb63425aff9b05836f029929e345a6148a14b7ecd5ab67af944482"
 561 | dependencies = [
 562 |  "bytes",
 563 |  "fnv",
 564 |  "itoa",
 565 | ]
 566 | 
 567 | [[package]]
 568 | name = "http-body"
 569 | version = "0.4.5"
 570 | source = "registry+https://github.com/rust-lang/crates.io-index"
 571 | checksum = "d5f38f16d184e36f2408a55281cd658ecbd3ca05cce6d6510a176eca393e26d1"
 572 | dependencies = [
 573 |  "bytes",
 574 |  "http",
 575 |  "pin-project-lite",
 576 | ]
 577 | 
 578 | [[package]]
 579 | name = "httparse"
 580 | version = "1.8.0"
 581 | source = "registry+https://github.com/rust-lang/crates.io-index"
 582 | checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
 583 | 
 584 | [[package]]
 585 | name = "httpdate"
 586 | version = "1.0.3"
 587 | source = "registry+https://github.com/rust-lang/crates.io-index"
 588 | checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
 589 | 
 590 | [[package]]
 591 | name = "humantime"
 592 | version = "2.1.0"
 593 | source = "registry+https://github.com/rust-lang/crates.io-index"
 594 | checksum = "9a3a5bfb195931eeb336b2a7b4d761daec841b97f947d34394601737a7bba5e4"
 595 | 
 596 | [[package]]
 597 | name = "hyper"
 598 | version = "0.14.27"
 599 | source = "registry+https://github.com/rust-lang/crates.io-index"
 600 | checksum = "ffb1cfd654a8219eaef89881fdb3bb3b1cdc5fa75ded05d6933b2b382e395468"
 601 | dependencies = [
 602 |  "bytes",
 603 |  "futures-channel",
 604 |  "futures-core",
 605 |  "futures-util",
 606 |  "h2",
 607 |  "http",
 608 |  "http-body",
 609 |  "httparse",
 610 |  "httpdate",
 611 |  "itoa",
 612 |  "pin-project-lite",
 613 |  "socket2 0.4.9",
 614 |  "tokio",
 615 |  "tower-service",
 616 |  "tracing",
 617 |  "want",
 618 | ]
 619 | 
 620 | [[package]]
 621 | name = "hyper-tls"
 622 | version = "0.5.0"
 623 | source = "registry+https://github.com/rust-lang/crates.io-index"
 624 | checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
 625 | dependencies = [
 626 |  "bytes",
 627 |  "hyper",
 628 |  "native-tls",
 629 |  "tokio",
 630 |  "tokio-native-tls",
 631 | ]
 632 | 
 633 | [[package]]
 634 | name = "iana-time-zone"
 635 | version = "0.1.57"
 636 | source = "registry+https://github.com/rust-lang/crates.io-index"
 637 | checksum = "2fad5b825842d2b38bd206f3e81d6957625fd7f0a361e345c30e01a0ae2dd613"
 638 | dependencies = [
 639 |  "android_system_properties",
 640 |  "core-foundation-sys",
 641 |  "iana-time-zone-haiku",
 642 |  "js-sys",
 643 |  "wasm-bindgen",
 644 |  "windows",
 645 | ]
 646 | 
 647 | [[package]]
 648 | name = "iana-time-zone-haiku"
 649 | version = "0.1.2"
 650 | source = "registry+https://github.com/rust-lang/crates.io-index"
 651 | checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
 652 | dependencies = [
 653 |  "cc",
 654 | ]
 655 | 
 656 | [[package]]
 657 | name = "ident_case"
 658 | version = "1.0.1"
 659 | source = "registry+https://github.com/rust-lang/crates.io-index"
 660 | checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
 661 | 
 662 | [[package]]
 663 | name = "idna"
 664 | version = "0.4.0"
 665 | source = "registry+https://github.com/rust-lang/crates.io-index"
 666 | checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
 667 | dependencies = [
 668 |  "unicode-bidi",
 669 |  "unicode-normalization",
 670 | ]
 671 | 
 672 | [[package]]
 673 | name = "indexmap"
 674 | version = "1.9.3"
 675 | source = "registry+https://github.com/rust-lang/crates.io-index"
 676 | checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
 677 | dependencies = [
 678 |  "autocfg",
 679 |  "hashbrown 0.12.3",
 680 | ]
 681 | 
 682 | [[package]]
 683 | name = "ipnet"
 684 | version = "2.8.0"
 685 | source = "registry+https://github.com/rust-lang/crates.io-index"
 686 | checksum = "28b29a3cd74f0f4598934efe3aeba42bae0eb4680554128851ebbecb02af14e6"
 687 | 
 688 | [[package]]
 689 | name = "itertools"
 690 | version = "0.9.0"
 691 | source = "registry+https://github.com/rust-lang/crates.io-index"
 692 | checksum = "284f18f85651fe11e8a991b2adb42cb078325c996ed026d994719efcfca1d54b"
 693 | dependencies = [
 694 |  "either",
 695 | ]
 696 | 
 697 | [[package]]
 698 | name = "itertools"
 699 | version = "0.10.5"
 700 | source = "registry+https://github.com/rust-lang/crates.io-index"
 701 | checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
 702 | dependencies = [
 703 |  "either",
 704 | ]
 705 | 
 706 | [[package]]
 707 | name = "itoa"
 708 | version = "1.0.9"
 709 | source = "registry+https://github.com/rust-lang/crates.io-index"
 710 | checksum = "af150ab688ff2122fcef229be89cb50dd66af9e01a4ff320cc137eecc9bacc38"
 711 | 
 712 | [[package]]
 713 | name = "js-sys"
 714 | version = "0.3.64"
 715 | source = "registry+https://github.com/rust-lang/crates.io-index"
 716 | checksum = "c5f195fe497f702db0f318b07fdd68edb16955aed830df8363d837542f8f935a"
 717 | dependencies = [
 718 |  "wasm-bindgen",
 719 | ]
 720 | 
 721 | [[package]]
 722 | name = "lazy_static"
 723 | version = "1.4.0"
 724 | source = "registry+https://github.com/rust-lang/crates.io-index"
 725 | checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 726 | 
 727 | [[package]]
 728 | name = "libc"
 729 | version = "0.2.147"
 730 | source = "registry+https://github.com/rust-lang/crates.io-index"
 731 | checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
 732 | 
 733 | [[package]]
 734 | name = "libsqlite3-sys"
 735 | version = "0.25.2"
 736 | source = "registry+https://github.com/rust-lang/crates.io-index"
 737 | checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
 738 | dependencies = [
 739 |  "cc",
 740 |  "pkg-config",
 741 |  "vcpkg",
 742 | ]
 743 | 
 744 | [[package]]
 745 | name = "linux-raw-sys"
 746 | version = "0.4.5"
 747 | source = "registry+https://github.com/rust-lang/crates.io-index"
 748 | checksum = "57bcfdad1b858c2db7c38303a6d2ad4dfaf5eb53dfeb0910128b2c26d6158503"
 749 | 
 750 | [[package]]
 751 | name = "log"
 752 | version = "0.4.20"
 753 | source = "registry+https://github.com/rust-lang/crates.io-index"
 754 | checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
 755 | 
 756 | [[package]]
 757 | name = "memchr"
 758 | version = "2.5.0"
 759 | source = "registry+https://github.com/rust-lang/crates.io-index"
 760 | checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
 761 | 
 762 | [[package]]
 763 | name = "mime"
 764 | version = "0.3.17"
 765 | source = "registry+https://github.com/rust-lang/crates.io-index"
 766 | checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 767 | 
 768 | [[package]]
 769 | name = "mime_guess"
 770 | version = "2.0.4"
 771 | source = "registry+https://github.com/rust-lang/crates.io-index"
 772 | checksum = "4192263c238a5f0d0c6bfd21f336a313a4ce1c450542449ca191bb657b4642ef"
 773 | dependencies = [
 774 |  "mime",
 775 |  "unicase",
 776 | ]
 777 | 
 778 | [[package]]
 779 | name = "miniz_oxide"
 780 | version = "0.7.1"
 781 | source = "registry+https://github.com/rust-lang/crates.io-index"
 782 | checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
 783 | dependencies = [
 784 |  "adler",
 785 | ]
 786 | 
 787 | [[package]]
 788 | name = "mio"
 789 | version = "0.8.8"
 790 | source = "registry+https://github.com/rust-lang/crates.io-index"
 791 | checksum = "927a765cd3fc26206e66b296465fa9d3e5ab003e651c1b3c060e7956d96b19d2"
 792 | dependencies = [
 793 |  "libc",
 794 |  "wasi 0.11.0+wasi-snapshot-preview1",
 795 |  "windows-sys",
 796 | ]
 797 | 
 798 | [[package]]
 799 | name = "native-tls"
 800 | version = "0.2.11"
 801 | source = "registry+https://github.com/rust-lang/crates.io-index"
 802 | checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
 803 | dependencies = [
 804 |  "lazy_static",
 805 |  "libc",
 806 |  "log",
 807 |  "openssl",
 808 |  "openssl-probe",
 809 |  "openssl-sys",
 810 |  "schannel",
 811 |  "security-framework",
 812 |  "security-framework-sys",
 813 |  "tempfile",
 814 | ]
 815 | 
 816 | [[package]]
 817 | name = "never"
 818 | version = "0.1.0"
 819 | source = "registry+https://github.com/rust-lang/crates.io-index"
 820 | checksum = "c96aba5aa877601bb3f6dd6a63a969e1f82e60646e81e71b14496995e9853c91"
 821 | 
 822 | [[package]]
 823 | name = "num-traits"
 824 | version = "0.2.16"
 825 | source = "registry+https://github.com/rust-lang/crates.io-index"
 826 | checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
 827 | dependencies = [
 828 |  "autocfg",
 829 | ]
 830 | 
 831 | [[package]]
 832 | name = "num_cpus"
 833 | version = "1.16.0"
 834 | source = "registry+https://github.com/rust-lang/crates.io-index"
 835 | checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
 836 | dependencies = [
 837 |  "hermit-abi 0.3.2",
 838 |  "libc",
 839 | ]
 840 | 
 841 | [[package]]
 842 | name = "object"
 843 | version = "0.32.0"
 844 | source = "registry+https://github.com/rust-lang/crates.io-index"
 845 | checksum = "77ac5bbd07aea88c60a577a1ce218075ffd59208b2d7ca97adf9bfc5aeb21ebe"
 846 | dependencies = [
 847 |  "memchr",
 848 | ]
 849 | 
 850 | [[package]]
 851 | name = "once_cell"
 852 | version = "1.18.0"
 853 | source = "registry+https://github.com/rust-lang/crates.io-index"
 854 | checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
 855 | 
 856 | [[package]]
 857 | name = "openssl"
 858 | version = "0.10.56"
 859 | source = "registry+https://github.com/rust-lang/crates.io-index"
 860 | checksum = "729b745ad4a5575dd06a3e1af1414bd330ee561c01b3899eb584baeaa8def17e"
 861 | dependencies = [
 862 |  "bitflags 1.3.2",
 863 |  "cfg-if",
 864 |  "foreign-types",
 865 |  "libc",
 866 |  "once_cell",
 867 |  "openssl-macros",
 868 |  "openssl-sys",
 869 | ]
 870 | 
 871 | [[package]]
 872 | name = "openssl-macros"
 873 | version = "0.1.1"
 874 | source = "registry+https://github.com/rust-lang/crates.io-index"
 875 | checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
 876 | dependencies = [
 877 |  "proc-macro2",
 878 |  "quote",
 879 |  "syn 2.0.29",
 880 | ]
 881 | 
 882 | [[package]]
 883 | name = "openssl-probe"
 884 | version = "0.1.5"
 885 | source = "registry+https://github.com/rust-lang/crates.io-index"
 886 | checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
 887 | 
 888 | [[package]]
 889 | name = "openssl-src"
 890 | version = "111.27.0+1.1.1v"
 891 | source = "registry+https://github.com/rust-lang/crates.io-index"
 892 | checksum = "06e8f197c82d7511c5b014030c9b1efeda40d7d5f99d23b4ceed3524a5e63f02"
 893 | dependencies = [
 894 |  "cc",
 895 | ]
 896 | 
 897 | [[package]]
 898 | name = "openssl-sys"
 899 | version = "0.9.91"
 900 | source = "registry+https://github.com/rust-lang/crates.io-index"
 901 | checksum = "866b5f16f90776b9bb8dc1e1802ac6f0513de3a7a7465867bfbc563dc737faac"
 902 | dependencies = [
 903 |  "cc",
 904 |  "libc",
 905 |  "openssl-src",
 906 |  "pkg-config",
 907 |  "vcpkg",
 908 | ]
 909 | 
 910 | [[package]]
 911 | name = "os_pipe"
 912 | version = "1.1.4"
 913 | source = "registry+https://github.com/rust-lang/crates.io-index"
 914 | checksum = "0ae859aa07428ca9a929b936690f8b12dc5f11dd8c6992a18ca93919f28bc177"
 915 | dependencies = [
 916 |  "libc",
 917 |  "windows-sys",
 918 | ]
 919 | 
 920 | [[package]]
 921 | name = "percent-encoding"
 922 | version = "2.3.0"
 923 | source = "registry+https://github.com/rust-lang/crates.io-index"
 924 | checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
 925 | 
 926 | [[package]]
 927 | name = "pin-project"
 928 | version = "1.1.3"
 929 | source = "registry+https://github.com/rust-lang/crates.io-index"
 930 | checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422"
 931 | dependencies = [
 932 |  "pin-project-internal",
 933 | ]
 934 | 
 935 | [[package]]
 936 | name = "pin-project-internal"
 937 | version = "1.1.3"
 938 | source = "registry+https://github.com/rust-lang/crates.io-index"
 939 | checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405"
 940 | dependencies = [
 941 |  "proc-macro2",
 942 |  "quote",
 943 |  "syn 2.0.29",
 944 | ]
 945 | 
 946 | [[package]]
 947 | name = "pin-project-lite"
 948 | version = "0.2.13"
 949 | source = "registry+https://github.com/rust-lang/crates.io-index"
 950 | checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
 951 | 
 952 | [[package]]
 953 | name = "pin-utils"
 954 | version = "0.1.0"
 955 | source = "registry+https://github.com/rust-lang/crates.io-index"
 956 | checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
 957 | 
 958 | [[package]]
 959 | name = "pkg-config"
 960 | version = "0.3.27"
 961 | source = "registry+https://github.com/rust-lang/crates.io-index"
 962 | checksum = "26072860ba924cbfa98ea39c8c19b4dd6a4a25423dbdf219c1eca91aa0cf6964"
 963 | 
 964 | [[package]]
 965 | name = "proc-macro-error"
 966 | version = "1.0.4"
 967 | source = "registry+https://github.com/rust-lang/crates.io-index"
 968 | checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
 969 | dependencies = [
 970 |  "proc-macro-error-attr",
 971 |  "proc-macro2",
 972 |  "quote",
 973 |  "syn 1.0.109",
 974 |  "version_check",
 975 | ]
 976 | 
 977 | [[package]]
 978 | name = "proc-macro-error-attr"
 979 | version = "1.0.4"
 980 | source = "registry+https://github.com/rust-lang/crates.io-index"
 981 | checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
 982 | dependencies = [
 983 |  "proc-macro2",
 984 |  "quote",
 985 |  "version_check",
 986 | ]
 987 | 
 988 | [[package]]
 989 | name = "proc-macro2"
 990 | version = "1.0.66"
 991 | source = "registry+https://github.com/rust-lang/crates.io-index"
 992 | checksum = "18fb31db3f9bddb2ea821cde30a9f70117e3f119938b5ee630b7403aa6e2ead9"
 993 | dependencies = [
 994 |  "unicode-ident",
 995 | ]
 996 | 
 997 | [[package]]
 998 | name = "quote"
 999 | version = "1.0.33"
1000 | source = "registry+https://github.com/rust-lang/crates.io-index"
1001 | checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
1002 | dependencies = [
1003 |  "proc-macro2",
1004 | ]
1005 | 
1006 | [[package]]
1007 | name = "rand"
1008 | version = "0.4.6"
1009 | source = "registry+https://github.com/rust-lang/crates.io-index"
1010 | checksum = "552840b97013b1a26992c11eac34bdd778e464601a4c2054b5f0bff7c6761293"
1011 | dependencies = [
1012 |  "fuchsia-cprng",
1013 |  "libc",
1014 |  "rand_core 0.3.1",
1015 |  "rdrand",
1016 |  "winapi",
1017 | ]
1018 | 
1019 | [[package]]
1020 | name = "rand_core"
1021 | version = "0.3.1"
1022 | source = "registry+https://github.com/rust-lang/crates.io-index"
1023 | checksum = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
1024 | dependencies = [
1025 |  "rand_core 0.4.2",
1026 | ]
1027 | 
1028 | [[package]]
1029 | name = "rand_core"
1030 | version = "0.4.2"
1031 | source = "registry+https://github.com/rust-lang/crates.io-index"
1032 | checksum = "9c33a3c44ca05fa6f1807d8e6743f3824e8509beca625669633be0acbdf509dc"
1033 | 
1034 | [[package]]
1035 | name = "rc-box"
1036 | version = "1.2.0"
1037 | source = "registry+https://github.com/rust-lang/crates.io-index"
1038 | checksum = "e0690759eabf094030c2cdabc25ade1395bac02210d920d655053c1d49583fd8"
1039 | dependencies = [
1040 |  "erasable",
1041 | ]
1042 | 
1043 | [[package]]
1044 | name = "rdrand"
1045 | version = "0.4.0"
1046 | source = "registry+https://github.com/rust-lang/crates.io-index"
1047 | checksum = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
1048 | dependencies = [
1049 |  "rand_core 0.3.1",
1050 | ]
1051 | 
1052 | [[package]]
1053 | name = "redox_syscall"
1054 | version = "0.3.5"
1055 | source = "registry+https://github.com/rust-lang/crates.io-index"
1056 | checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
1057 | dependencies = [
1058 |  "bitflags 1.3.2",
1059 | ]
1060 | 
1061 | [[package]]
1062 | name = "regex"
1063 | version = "1.9.3"
1064 | source = "registry+https://github.com/rust-lang/crates.io-index"
1065 | checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
1066 | dependencies = [
1067 |  "aho-corasick",
1068 |  "memchr",
1069 |  "regex-automata",
1070 |  "regex-syntax",
1071 | ]
1072 | 
1073 | [[package]]
1074 | name = "regex-automata"
1075 | version = "0.3.6"
1076 | source = "registry+https://github.com/rust-lang/crates.io-index"
1077 | checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
1078 | dependencies = [
1079 |  "aho-corasick",
1080 |  "memchr",
1081 |  "regex-syntax",
1082 | ]
1083 | 
1084 | [[package]]
1085 | name = "regex-syntax"
1086 | version = "0.7.4"
1087 | source = "registry+https://github.com/rust-lang/crates.io-index"
1088 | checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
1089 | 
1090 | [[package]]
1091 | name = "remove_dir_all"
1092 | version = "0.5.3"
1093 | source = "registry+https://github.com/rust-lang/crates.io-index"
1094 | checksum = "3acd125665422973a33ac9d3dd2df85edad0f4ae9b00dafb1a05e43a9f5ef8e7"
1095 | dependencies = [
1096 |  "winapi",
1097 | ]
1098 | 
1099 | [[package]]
1100 | name = "reqwest"
1101 | version = "0.11.20"
1102 | source = "registry+https://github.com/rust-lang/crates.io-index"
1103 | checksum = "3e9ad3fe7488d7e34558a2033d45a0c90b72d97b4f80705666fea71472e2e6a1"
1104 | dependencies = [
1105 |  "base64",
1106 |  "bytes",
1107 |  "encoding_rs",
1108 |  "futures-core",
1109 |  "futures-util",
1110 |  "h2",
1111 |  "http",
1112 |  "http-body",
1113 |  "hyper",
1114 |  "hyper-tls",
1115 |  "ipnet",
1116 |  "js-sys",
1117 |  "log",
1118 |  "mime",
1119 |  "mime_guess",
1120 |  "native-tls",
1121 |  "once_cell",
1122 |  "percent-encoding",
1123 |  "pin-project-lite",
1124 |  "serde",
1125 |  "serde_json",
1126 |  "serde_urlencoded",
1127 |  "tokio",
1128 |  "tokio-native-tls",
1129 |  "tokio-util",
1130 |  "tower-service",
1131 |  "url",
1132 |  "wasm-bindgen",
1133 |  "wasm-bindgen-futures",
1134 |  "wasm-streams",
1135 |  "web-sys",
1136 |  "winreg",
1137 | ]
1138 | 
1139 | [[package]]
1140 | name = "rusqlite"
1141 | version = "0.28.0"
1142 | source = "registry+https://github.com/rust-lang/crates.io-index"
1143 | checksum = "01e213bc3ecb39ac32e81e51ebe31fd888a940515173e3a18a35f8c6e896422a"
1144 | dependencies = [
1145 |  "bitflags 1.3.2",
1146 |  "chrono",
1147 |  "fallible-iterator",
1148 |  "fallible-streaming-iterator",
1149 |  "hashlink",
1150 |  "libsqlite3-sys",
1151 |  "smallvec",
1152 | ]
1153 | 
1154 | [[package]]
1155 | name = "rusqlite_migration"
1156 | version = "1.0.2"
1157 | source = "registry+https://github.com/rust-lang/crates.io-index"
1158 | checksum = "ef7dd29a4426624704d5966416682fb7ab3682f724986e9e3893eaca44accabc"
1159 | dependencies = [
1160 |  "log",
1161 |  "rusqlite",
1162 | ]
1163 | 
1164 | [[package]]
1165 | name = "rustc-demangle"
1166 | version = "0.1.23"
1167 | source = "registry+https://github.com/rust-lang/crates.io-index"
1168 | checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
1169 | 
1170 | [[package]]
1171 | name = "rustc_version"
1172 | version = "0.4.0"
1173 | source = "registry+https://github.com/rust-lang/crates.io-index"
1174 | checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366"
1175 | dependencies = [
1176 |  "semver",
1177 | ]
1178 | 
1179 | [[package]]
1180 | name = "rustix"
1181 | version = "0.38.8"
1182 | source = "registry+https://github.com/rust-lang/crates.io-index"
1183 | checksum = "19ed4fa021d81c8392ce04db050a3da9a60299050b7ae1cf482d862b54a7218f"
1184 | dependencies = [
1185 |  "bitflags 2.4.0",
1186 |  "errno",
1187 |  "libc",
1188 |  "linux-raw-sys",
1189 |  "windows-sys",
1190 | ]
1191 | 
1192 | [[package]]
1193 | name = "rustversion"
1194 | version = "1.0.14"
1195 | source = "registry+https://github.com/rust-lang/crates.io-index"
1196 | checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
1197 | 
1198 | [[package]]
1199 | name = "ryu"
1200 | version = "1.0.15"
1201 | source = "registry+https://github.com/rust-lang/crates.io-index"
1202 | checksum = "1ad4cc8da4ef723ed60bced201181d83791ad433213d8c24efffda1eec85d741"
1203 | 
1204 | [[package]]
1205 | name = "schannel"
1206 | version = "0.1.22"
1207 | source = "registry+https://github.com/rust-lang/crates.io-index"
1208 | checksum = "0c3733bf4cf7ea0880754e19cb5a462007c4a8c1914bff372ccc95b464f1df88"
1209 | dependencies = [
1210 |  "windows-sys",
1211 | ]
1212 | 
1213 | [[package]]
1214 | name = "scopeguard"
1215 | version = "1.2.0"
1216 | source = "registry+https://github.com/rust-lang/crates.io-index"
1217 | checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
1218 | 
1219 | [[package]]
1220 | name = "secrecy"
1221 | version = "0.8.0"
1222 | source = "registry+https://github.com/rust-lang/crates.io-index"
1223 | checksum = "9bd1c54ea06cfd2f6b63219704de0b9b4f72dcc2b8fdef820be6cd799780e91e"
1224 | dependencies = [
1225 |  "serde",
1226 |  "zeroize",
1227 | ]
1228 | 
1229 | [[package]]
1230 | name = "security-framework"
1231 | version = "2.9.2"
1232 | source = "registry+https://github.com/rust-lang/crates.io-index"
1233 | checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
1234 | dependencies = [
1235 |  "bitflags 1.3.2",
1236 |  "core-foundation",
1237 |  "core-foundation-sys",
1238 |  "libc",
1239 |  "security-framework-sys",
1240 | ]
1241 | 
1242 | [[package]]
1243 | name = "security-framework-sys"
1244 | version = "2.9.1"
1245 | source = "registry+https://github.com/rust-lang/crates.io-index"
1246 | checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
1247 | dependencies = [
1248 |  "core-foundation-sys",
1249 |  "libc",
1250 | ]
1251 | 
1252 | [[package]]
1253 | name = "semver"
1254 | version = "1.0.18"
1255 | source = "registry+https://github.com/rust-lang/crates.io-index"
1256 | checksum = "b0293b4b29daaf487284529cc2f5675b8e57c61f70167ba415a463651fd6a918"
1257 | 
1258 | [[package]]
1259 | name = "serde"
1260 | version = "1.0.187"
1261 | source = "registry+https://github.com/rust-lang/crates.io-index"
1262 | checksum = "30a7fe14252655bd1e578af19f5fa00fe02fd0013b100ca6b49fde31c41bae4c"
1263 | dependencies = [
1264 |  "serde_derive",
1265 | ]
1266 | 
1267 | [[package]]
1268 | name = "serde_derive"
1269 | version = "1.0.187"
1270 | source = "registry+https://github.com/rust-lang/crates.io-index"
1271 | checksum = "e46b2a6ca578b3f1d4501b12f78ed4692006d79d82a1a7c561c12dbc3d625eb8"
1272 | dependencies = [
1273 |  "proc-macro2",
1274 |  "quote",
1275 |  "syn 2.0.29",
1276 | ]
1277 | 
1278 | [[package]]
1279 | name = "serde_json"
1280 | version = "1.0.105"
1281 | source = "registry+https://github.com/rust-lang/crates.io-index"
1282 | checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
1283 | dependencies = [
1284 |  "itoa",
1285 |  "ryu",
1286 |  "serde",
1287 | ]
1288 | 
1289 | [[package]]
1290 | name = "serde_urlencoded"
1291 | version = "0.7.1"
1292 | source = "registry+https://github.com/rust-lang/crates.io-index"
1293 | checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
1294 | dependencies = [
1295 |  "form_urlencoded",
1296 |  "itoa",
1297 |  "ryu",
1298 |  "serde",
1299 | ]
1300 | 
1301 | [[package]]
1302 | name = "serde_with_macros"
1303 | version = "1.5.2"
1304 | source = "registry+https://github.com/rust-lang/crates.io-index"
1305 | checksum = "e182d6ec6f05393cc0e5ed1bf81ad6db3a8feedf8ee515ecdd369809bcce8082"
1306 | dependencies = [
1307 |  "darling",
1308 |  "proc-macro2",
1309 |  "quote",
1310 |  "syn 1.0.109",
1311 | ]
1312 | 
1313 | [[package]]
1314 | name = "shared_child"
1315 | version = "1.0.0"
1316 | source = "registry+https://github.com/rust-lang/crates.io-index"
1317 | checksum = "b0d94659ad3c2137fef23ae75b03d5241d633f8acded53d672decfa0e6e0caef"
1318 | dependencies = [
1319 |  "libc",
1320 |  "winapi",
1321 | ]
1322 | 
1323 | [[package]]
1324 | name = "signal-hook"
1325 | version = "0.3.17"
1326 | source = "registry+https://github.com/rust-lang/crates.io-index"
1327 | checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
1328 | dependencies = [
1329 |  "libc",
1330 |  "signal-hook-registry",
1331 | ]
1332 | 
1333 | [[package]]
1334 | name = "signal-hook-registry"
1335 | version = "1.4.1"
1336 | source = "registry+https://github.com/rust-lang/crates.io-index"
1337 | checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
1338 | dependencies = [
1339 |  "libc",
1340 | ]
1341 | 
1342 | [[package]]
1343 | name = "slab"
1344 | version = "0.4.9"
1345 | source = "registry+https://github.com/rust-lang/crates.io-index"
1346 | checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
1347 | dependencies = [
1348 |  "autocfg",
1349 | ]
1350 | 
1351 | [[package]]
1352 | name = "smallvec"
1353 | version = "1.11.0"
1354 | source = "registry+https://github.com/rust-lang/crates.io-index"
1355 | checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
1356 | 
1357 | [[package]]
1358 | name = "socket2"
1359 | version = "0.4.9"
1360 | source = "registry+https://github.com/rust-lang/crates.io-index"
1361 | checksum = "64a4a911eed85daf18834cfaa86a79b7d266ff93ff5ba14005426219480ed662"
1362 | dependencies = [
1363 |  "libc",
1364 |  "winapi",
1365 | ]
1366 | 
1367 | [[package]]
1368 | name = "socket2"
1369 | version = "0.5.3"
1370 | source = "registry+https://github.com/rust-lang/crates.io-index"
1371 | checksum = "2538b18701741680e0322a2302176d3253a35388e2e62f172f64f4f16605f877"
1372 | dependencies = [
1373 |  "libc",
1374 |  "windows-sys",
1375 | ]
1376 | 
1377 | [[package]]
1378 | name = "strsim"
1379 | version = "0.10.0"
1380 | source = "registry+https://github.com/rust-lang/crates.io-index"
1381 | checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
1382 | 
1383 | [[package]]
1384 | name = "strum"
1385 | version = "0.24.1"
1386 | source = "registry+https://github.com/rust-lang/crates.io-index"
1387 | checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f"
1388 | 
1389 | [[package]]
1390 | name = "strum_macros"
1391 | version = "0.24.3"
1392 | source = "registry+https://github.com/rust-lang/crates.io-index"
1393 | checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59"
1394 | dependencies = [
1395 |  "heck",
1396 |  "proc-macro2",
1397 |  "quote",
1398 |  "rustversion",
1399 |  "syn 1.0.109",
1400 | ]
1401 | 
1402 | [[package]]
1403 | name = "syn"
1404 | version = "1.0.109"
1405 | source = "registry+https://github.com/rust-lang/crates.io-index"
1406 | checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
1407 | dependencies = [
1408 |  "proc-macro2",
1409 |  "quote",
1410 |  "unicode-ident",
1411 | ]
1412 | 
1413 | [[package]]
1414 | name = "syn"
1415 | version = "2.0.29"
1416 | source = "registry+https://github.com/rust-lang/crates.io-index"
1417 | checksum = "c324c494eba9d92503e6f1ef2e6df781e78f6a7705a0202d9801b198807d518a"
1418 | dependencies = [
1419 |  "proc-macro2",
1420 |  "quote",
1421 |  "unicode-ident",
1422 | ]
1423 | 
1424 | [[package]]
1425 | name = "take_mut"
1426 | version = "0.2.2"
1427 | source = "registry+https://github.com/rust-lang/crates.io-index"
1428 | checksum = "f764005d11ee5f36500a149ace24e00e3da98b0158b3e2d53a7495660d3f4d60"
1429 | 
1430 | [[package]]
1431 | name = "takecell"
1432 | version = "0.1.1"
1433 | source = "registry+https://github.com/rust-lang/crates.io-index"
1434 | checksum = "20f34339676cdcab560c9a82300c4c2581f68b9369aedf0fae86f2ff9565ff3e"
1435 | 
1436 | [[package]]
1437 | name = "teloxide"
1438 | version = "0.12.2"
1439 | source = "registry+https://github.com/rust-lang/crates.io-index"
1440 | checksum = "c63345cf32a8850ebddcdd769dc2d5193d5e231262d5dada264b79da01a664da"
1441 | dependencies = [
1442 |  "aquamarine",
1443 |  "bytes",
1444 |  "derive_more",
1445 |  "dptree",
1446 |  "futures",
1447 |  "log",
1448 |  "mime",
1449 |  "pin-project",
1450 |  "serde",
1451 |  "serde_json",
1452 |  "serde_with_macros",
1453 |  "teloxide-core",
1454 |  "teloxide-macros",
1455 |  "thiserror",
1456 |  "tokio",
1457 |  "tokio-stream",
1458 |  "tokio-util",
1459 |  "url",
1460 | ]
1461 | 
1462 | [[package]]
1463 | name = "teloxide-core"
1464 | version = "0.9.1"
1465 | source = "registry+https://github.com/rust-lang/crates.io-index"
1466 | checksum = "303db260110c238e3af77bb9dff18bf7a5b5196f783059b0852aab75f91d5a16"
1467 | dependencies = [
1468 |  "bitflags 1.3.2",
1469 |  "bytes",
1470 |  "chrono",
1471 |  "derive_more",
1472 |  "either",
1473 |  "futures",
1474 |  "log",
1475 |  "mime",
1476 |  "never",
1477 |  "once_cell",
1478 |  "pin-project",
1479 |  "rc-box",
1480 |  "reqwest",
1481 |  "serde",
1482 |  "serde_json",
1483 |  "serde_with_macros",
1484 |  "take_mut",
1485 |  "takecell",
1486 |  "thiserror",
1487 |  "tokio",
1488 |  "tokio-util",
1489 |  "url",
1490 |  "uuid",
1491 | ]
1492 | 
1493 | [[package]]
1494 | name = "teloxide-macros"
1495 | version = "0.7.1"
1496 | source = "registry+https://github.com/rust-lang/crates.io-index"
1497 | checksum = "0f1d653b093dba5e44cada57a516f572167df37b8a619443e59c8c517bb6d804"
1498 | dependencies = [
1499 |  "heck",
1500 |  "proc-macro2",
1501 |  "quote",
1502 |  "syn 1.0.109",
1503 | ]
1504 | 
1505 | [[package]]
1506 | name = "tempdir"
1507 | version = "0.3.7"
1508 | source = "registry+https://github.com/rust-lang/crates.io-index"
1509 | checksum = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
1510 | dependencies = [
1511 |  "rand",
1512 |  "remove_dir_all",
1513 | ]
1514 | 
1515 | [[package]]
1516 | name = "tempfile"
1517 | version = "3.8.0"
1518 | source = "registry+https://github.com/rust-lang/crates.io-index"
1519 | checksum = "cb94d2f3cc536af71caac6b6fcebf65860b347e7ce0cc9ebe8f70d3e521054ef"
1520 | dependencies = [
1521 |  "cfg-if",
1522 |  "fastrand",
1523 |  "redox_syscall",
1524 |  "rustix",
1525 |  "windows-sys",
1526 | ]
1527 | 
1528 | [[package]]
1529 | name = "termcolor"
1530 | version = "1.2.0"
1531 | source = "registry+https://github.com/rust-lang/crates.io-index"
1532 | checksum = "be55cf8942feac5c765c2c993422806843c9a9a45d4d5c407ad6dd2ea95eb9b6"
1533 | dependencies = [
1534 |  "winapi-util",
1535 | ]
1536 | 
1537 | [[package]]
1538 | name = "tgreddit"
1539 | version = "0.1.4"
1540 | dependencies = [
1541 |  "anyhow",
1542 |  "chrono",
1543 |  "duct",
1544 |  "env_logger",
1545 |  "getopts",
1546 |  "itertools 0.10.5",
1547 |  "lazy_static",
1548 |  "log",
1549 |  "openssl",
1550 |  "regex",
1551 |  "reqwest",
1552 |  "rusqlite",
1553 |  "rusqlite_migration",
1554 |  "secrecy",
1555 |  "serde",
1556 |  "serde_derive",
1557 |  "serde_json",
1558 |  "signal-hook",
1559 |  "strum",
1560 |  "strum_macros",
1561 |  "teloxide",
1562 |  "tempdir",
1563 |  "thiserror",
1564 |  "tokio",
1565 |  "toml",
1566 |  "url",
1567 |  "xdg",
1568 | ]
1569 | 
1570 | [[package]]
1571 | name = "thiserror"
1572 | version = "1.0.47"
1573 | source = "registry+https://github.com/rust-lang/crates.io-index"
1574 | checksum = "97a802ec30afc17eee47b2855fc72e0c4cd62be9b4efe6591edde0ec5bd68d8f"
1575 | dependencies = [
1576 |  "thiserror-impl",
1577 | ]
1578 | 
1579 | [[package]]
1580 | name = "thiserror-impl"
1581 | version = "1.0.47"
1582 | source = "registry+https://github.com/rust-lang/crates.io-index"
1583 | checksum = "6bb623b56e39ab7dcd4b1b98bb6c8f8d907ed255b18de254088016b27a8ee19b"
1584 | dependencies = [
1585 |  "proc-macro2",
1586 |  "quote",
1587 |  "syn 2.0.29",
1588 | ]
1589 | 
1590 | [[package]]
1591 | name = "time"
1592 | version = "0.1.45"
1593 | source = "registry+https://github.com/rust-lang/crates.io-index"
1594 | checksum = "1b797afad3f312d1c66a56d11d0316f916356d11bd158fbc6ca6389ff6bf805a"
1595 | dependencies = [
1596 |  "libc",
1597 |  "wasi 0.10.0+wasi-snapshot-preview1",
1598 |  "winapi",
1599 | ]
1600 | 
1601 | [[package]]
1602 | name = "tinyvec"
1603 | version = "1.6.0"
1604 | source = "registry+https://github.com/rust-lang/crates.io-index"
1605 | checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
1606 | dependencies = [
1607 |  "tinyvec_macros",
1608 | ]
1609 | 
1610 | [[package]]
1611 | name = "tinyvec_macros"
1612 | version = "0.1.1"
1613 | source = "registry+https://github.com/rust-lang/crates.io-index"
1614 | checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
1615 | 
1616 | [[package]]
1617 | name = "tokio"
1618 | version = "1.32.0"
1619 | source = "registry+https://github.com/rust-lang/crates.io-index"
1620 | checksum = "17ed6077ed6cd6c74735e21f37eb16dc3935f96878b1fe961074089cc80893f9"
1621 | dependencies = [
1622 |  "backtrace",
1623 |  "bytes",
1624 |  "libc",
1625 |  "mio",
1626 |  "num_cpus",
1627 |  "pin-project-lite",
1628 |  "signal-hook-registry",
1629 |  "socket2 0.5.3",
1630 |  "tokio-macros",
1631 |  "windows-sys",
1632 | ]
1633 | 
1634 | [[package]]
1635 | name = "tokio-macros"
1636 | version = "2.1.0"
1637 | source = "registry+https://github.com/rust-lang/crates.io-index"
1638 | checksum = "630bdcf245f78637c13ec01ffae6187cca34625e8c63150d424b59e55af2675e"
1639 | dependencies = [
1640 |  "proc-macro2",
1641 |  "quote",
1642 |  "syn 2.0.29",
1643 | ]
1644 | 
1645 | [[package]]
1646 | name = "tokio-native-tls"
1647 | version = "0.3.1"
1648 | source = "registry+https://github.com/rust-lang/crates.io-index"
1649 | checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
1650 | dependencies = [
1651 |  "native-tls",
1652 |  "tokio",
1653 | ]
1654 | 
1655 | [[package]]
1656 | name = "tokio-stream"
1657 | version = "0.1.14"
1658 | source = "registry+https://github.com/rust-lang/crates.io-index"
1659 | checksum = "397c988d37662c7dda6d2208364a706264bf3d6138b11d436cbac0ad38832842"
1660 | dependencies = [
1661 |  "futures-core",
1662 |  "pin-project-lite",
1663 |  "tokio",
1664 | ]
1665 | 
1666 | [[package]]
1667 | name = "tokio-util"
1668 | version = "0.7.8"
1669 | source = "registry+https://github.com/rust-lang/crates.io-index"
1670 | checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d"
1671 | dependencies = [
1672 |  "bytes",
1673 |  "futures-core",
1674 |  "futures-sink",
1675 |  "pin-project-lite",
1676 |  "tokio",
1677 |  "tracing",
1678 | ]
1679 | 
1680 | [[package]]
1681 | name = "toml"
1682 | version = "0.5.11"
1683 | source = "registry+https://github.com/rust-lang/crates.io-index"
1684 | checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
1685 | dependencies = [
1686 |  "serde",
1687 | ]
1688 | 
1689 | [[package]]
1690 | name = "tower-service"
1691 | version = "0.3.2"
1692 | source = "registry+https://github.com/rust-lang/crates.io-index"
1693 | checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
1694 | 
1695 | [[package]]
1696 | name = "tracing"
1697 | version = "0.1.37"
1698 | source = "registry+https://github.com/rust-lang/crates.io-index"
1699 | checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
1700 | dependencies = [
1701 |  "cfg-if",
1702 |  "pin-project-lite",
1703 |  "tracing-core",
1704 | ]
1705 | 
1706 | [[package]]
1707 | name = "tracing-core"
1708 | version = "0.1.31"
1709 | source = "registry+https://github.com/rust-lang/crates.io-index"
1710 | checksum = "0955b8137a1df6f1a2e9a37d8a6656291ff0297c1a97c24e0d8425fe2312f79a"
1711 | dependencies = [
1712 |  "once_cell",
1713 | ]
1714 | 
1715 | [[package]]
1716 | name = "try-lock"
1717 | version = "0.2.4"
1718 | source = "registry+https://github.com/rust-lang/crates.io-index"
1719 | checksum = "3528ecfd12c466c6f163363caf2d02a71161dd5e1cc6ae7b34207ea2d42d81ed"
1720 | 
1721 | [[package]]
1722 | name = "unicase"
1723 | version = "2.7.0"
1724 | source = "registry+https://github.com/rust-lang/crates.io-index"
1725 | checksum = "f7d2d4dafb69621809a81864c9c1b864479e1235c0dd4e199924b9742439ed89"
1726 | dependencies = [
1727 |  "version_check",
1728 | ]
1729 | 
1730 | [[package]]
1731 | name = "unicode-bidi"
1732 | version = "0.3.13"
1733 | source = "registry+https://github.com/rust-lang/crates.io-index"
1734 | checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
1735 | 
1736 | [[package]]
1737 | name = "unicode-ident"
1738 | version = "1.0.11"
1739 | source = "registry+https://github.com/rust-lang/crates.io-index"
1740 | checksum = "301abaae475aa91687eb82514b328ab47a211a533026cb25fc3e519b86adfc3c"
1741 | 
1742 | [[package]]
1743 | name = "unicode-normalization"
1744 | version = "0.1.22"
1745 | source = "registry+https://github.com/rust-lang/crates.io-index"
1746 | checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
1747 | dependencies = [
1748 |  "tinyvec",
1749 | ]
1750 | 
1751 | [[package]]
1752 | name = "unicode-width"
1753 | version = "0.1.10"
1754 | source = "registry+https://github.com/rust-lang/crates.io-index"
1755 | checksum = "c0edd1e5b14653f783770bce4a4dabb4a5108a5370a5f5d8cfe8710c361f6c8b"
1756 | 
1757 | [[package]]
1758 | name = "url"
1759 | version = "2.4.0"
1760 | source = "registry+https://github.com/rust-lang/crates.io-index"
1761 | checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb"
1762 | dependencies = [
1763 |  "form_urlencoded",
1764 |  "idna",
1765 |  "percent-encoding",
1766 |  "serde",
1767 | ]
1768 | 
1769 | [[package]]
1770 | name = "uuid"
1771 | version = "1.4.1"
1772 | source = "registry+https://github.com/rust-lang/crates.io-index"
1773 | checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
1774 | dependencies = [
1775 |  "getrandom",
1776 | ]
1777 | 
1778 | [[package]]
1779 | name = "vcpkg"
1780 | version = "0.2.15"
1781 | source = "registry+https://github.com/rust-lang/crates.io-index"
1782 | checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
1783 | 
1784 | [[package]]
1785 | name = "version_check"
1786 | version = "0.9.4"
1787 | source = "registry+https://github.com/rust-lang/crates.io-index"
1788 | checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
1789 | 
1790 | [[package]]
1791 | name = "want"
1792 | version = "0.3.1"
1793 | source = "registry+https://github.com/rust-lang/crates.io-index"
1794 | checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
1795 | dependencies = [
1796 |  "try-lock",
1797 | ]
1798 | 
1799 | [[package]]
1800 | name = "wasi"
1801 | version = "0.10.0+wasi-snapshot-preview1"
1802 | source = "registry+https://github.com/rust-lang/crates.io-index"
1803 | checksum = "1a143597ca7c7793eff794def352d41792a93c481eb1042423ff7ff72ba2c31f"
1804 | 
1805 | [[package]]
1806 | name = "wasi"
1807 | version = "0.11.0+wasi-snapshot-preview1"
1808 | source = "registry+https://github.com/rust-lang/crates.io-index"
1809 | checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
1810 | 
1811 | [[package]]
1812 | name = "wasm-bindgen"
1813 | version = "0.2.87"
1814 | source = "registry+https://github.com/rust-lang/crates.io-index"
1815 | checksum = "7706a72ab36d8cb1f80ffbf0e071533974a60d0a308d01a5d0375bf60499a342"
1816 | dependencies = [
1817 |  "cfg-if",
1818 |  "wasm-bindgen-macro",
1819 | ]
1820 | 
1821 | [[package]]
1822 | name = "wasm-bindgen-backend"
1823 | version = "0.2.87"
1824 | source = "registry+https://github.com/rust-lang/crates.io-index"
1825 | checksum = "5ef2b6d3c510e9625e5fe6f509ab07d66a760f0885d858736483c32ed7809abd"
1826 | dependencies = [
1827 |  "bumpalo",
1828 |  "log",
1829 |  "once_cell",
1830 |  "proc-macro2",
1831 |  "quote",
1832 |  "syn 2.0.29",
1833 |  "wasm-bindgen-shared",
1834 | ]
1835 | 
1836 | [[package]]
1837 | name = "wasm-bindgen-futures"
1838 | version = "0.4.37"
1839 | source = "registry+https://github.com/rust-lang/crates.io-index"
1840 | checksum = "c02dbc21516f9f1f04f187958890d7e6026df8d16540b7ad9492bc34a67cea03"
1841 | dependencies = [
1842 |  "cfg-if",
1843 |  "js-sys",
1844 |  "wasm-bindgen",
1845 |  "web-sys",
1846 | ]
1847 | 
1848 | [[package]]
1849 | name = "wasm-bindgen-macro"
1850 | version = "0.2.87"
1851 | source = "registry+https://github.com/rust-lang/crates.io-index"
1852 | checksum = "dee495e55982a3bd48105a7b947fd2a9b4a8ae3010041b9e0faab3f9cd028f1d"
1853 | dependencies = [
1854 |  "quote",
1855 |  "wasm-bindgen-macro-support",
1856 | ]
1857 | 
1858 | [[package]]
1859 | name = "wasm-bindgen-macro-support"
1860 | version = "0.2.87"
1861 | source = "registry+https://github.com/rust-lang/crates.io-index"
1862 | checksum = "54681b18a46765f095758388f2d0cf16eb8d4169b639ab575a8f5693af210c7b"
1863 | dependencies = [
1864 |  "proc-macro2",
1865 |  "quote",
1866 |  "syn 2.0.29",
1867 |  "wasm-bindgen-backend",
1868 |  "wasm-bindgen-shared",
1869 | ]
1870 | 
1871 | [[package]]
1872 | name = "wasm-bindgen-shared"
1873 | version = "0.2.87"
1874 | source = "registry+https://github.com/rust-lang/crates.io-index"
1875 | checksum = "ca6ad05a4870b2bf5fe995117d3728437bd27d7cd5f06f13c17443ef369775a1"
1876 | 
1877 | [[package]]
1878 | name = "wasm-streams"
1879 | version = "0.3.0"
1880 | source = "registry+https://github.com/rust-lang/crates.io-index"
1881 | checksum = "b4609d447824375f43e1ffbc051b50ad8f4b3ae8219680c94452ea05eb240ac7"
1882 | dependencies = [
1883 |  "futures-util",
1884 |  "js-sys",
1885 |  "wasm-bindgen",
1886 |  "wasm-bindgen-futures",
1887 |  "web-sys",
1888 | ]
1889 | 
1890 | [[package]]
1891 | name = "web-sys"
1892 | version = "0.3.64"
1893 | source = "registry+https://github.com/rust-lang/crates.io-index"
1894 | checksum = "9b85cbef8c220a6abc02aefd892dfc0fc23afb1c6a426316ec33253a3877249b"
1895 | dependencies = [
1896 |  "js-sys",
1897 |  "wasm-bindgen",
1898 | ]
1899 | 
1900 | [[package]]
1901 | name = "winapi"
1902 | version = "0.3.9"
1903 | source = "registry+https://github.com/rust-lang/crates.io-index"
1904 | checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
1905 | dependencies = [
1906 |  "winapi-i686-pc-windows-gnu",
1907 |  "winapi-x86_64-pc-windows-gnu",
1908 | ]
1909 | 
1910 | [[package]]
1911 | name = "winapi-i686-pc-windows-gnu"
1912 | version = "0.4.0"
1913 | source = "registry+https://github.com/rust-lang/crates.io-index"
1914 | checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
1915 | 
1916 | [[package]]
1917 | name = "winapi-util"
1918 | version = "0.1.5"
1919 | source = "registry+https://github.com/rust-lang/crates.io-index"
1920 | checksum = "70ec6ce85bb158151cae5e5c87f95a8e97d2c0c4b001223f33a334e3ce5de178"
1921 | dependencies = [
1922 |  "winapi",
1923 | ]
1924 | 
1925 | [[package]]
1926 | name = "winapi-x86_64-pc-windows-gnu"
1927 | version = "0.4.0"
1928 | source = "registry+https://github.com/rust-lang/crates.io-index"
1929 | checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
1930 | 
1931 | [[package]]
1932 | name = "windows"
1933 | version = "0.48.0"
1934 | source = "registry+https://github.com/rust-lang/crates.io-index"
1935 | checksum = "e686886bc078bc1b0b600cac0147aadb815089b6e4da64016cbd754b6342700f"
1936 | dependencies = [
1937 |  "windows-targets",
1938 | ]
1939 | 
1940 | [[package]]
1941 | name = "windows-sys"
1942 | version = "0.48.0"
1943 | source = "registry+https://github.com/rust-lang/crates.io-index"
1944 | checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
1945 | dependencies = [
1946 |  "windows-targets",
1947 | ]
1948 | 
1949 | [[package]]
1950 | name = "windows-targets"
1951 | version = "0.48.5"
1952 | source = "registry+https://github.com/rust-lang/crates.io-index"
1953 | checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
1954 | dependencies = [
1955 |  "windows_aarch64_gnullvm",
1956 |  "windows_aarch64_msvc",
1957 |  "windows_i686_gnu",
1958 |  "windows_i686_msvc",
1959 |  "windows_x86_64_gnu",
1960 |  "windows_x86_64_gnullvm",
1961 |  "windows_x86_64_msvc",
1962 | ]
1963 | 
1964 | [[package]]
1965 | name = "windows_aarch64_gnullvm"
1966 | version = "0.48.5"
1967 | source = "registry+https://github.com/rust-lang/crates.io-index"
1968 | checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
1969 | 
1970 | [[package]]
1971 | name = "windows_aarch64_msvc"
1972 | version = "0.48.5"
1973 | source = "registry+https://github.com/rust-lang/crates.io-index"
1974 | checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
1975 | 
1976 | [[package]]
1977 | name = "windows_i686_gnu"
1978 | version = "0.48.5"
1979 | source = "registry+https://github.com/rust-lang/crates.io-index"
1980 | checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
1981 | 
1982 | [[package]]
1983 | name = "windows_i686_msvc"
1984 | version = "0.48.5"
1985 | source = "registry+https://github.com/rust-lang/crates.io-index"
1986 | checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
1987 | 
1988 | [[package]]
1989 | name = "windows_x86_64_gnu"
1990 | version = "0.48.5"
1991 | source = "registry+https://github.com/rust-lang/crates.io-index"
1992 | checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
1993 | 
1994 | [[package]]
1995 | name = "windows_x86_64_gnullvm"
1996 | version = "0.48.5"
1997 | source = "registry+https://github.com/rust-lang/crates.io-index"
1998 | checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
1999 | 
2000 | [[package]]
2001 | name = "windows_x86_64_msvc"
2002 | version = "0.48.5"
2003 | source = "registry+https://github.com/rust-lang/crates.io-index"
2004 | checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
2005 | 
2006 | [[package]]
2007 | name = "winreg"
2008 | version = "0.50.0"
2009 | source = "registry+https://github.com/rust-lang/crates.io-index"
2010 | checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
2011 | dependencies = [
2012 |  "cfg-if",
2013 |  "windows-sys",
2014 | ]
2015 | 
2016 | [[package]]
2017 | name = "xdg"
2018 | version = "2.5.2"
2019 | source = "registry+https://github.com/rust-lang/crates.io-index"
2020 | checksum = "213b7324336b53d2414b2db8537e56544d981803139155afa84f76eeebb7a546"
2021 | 
2022 | [[package]]
2023 | name = "zeroize"
2024 | version = "1.6.0"
2025 | source = "registry+https://github.com/rust-lang/crates.io-index"
2026 | checksum = "2a0956f1ba7c7909bfb66c2e9e4124ab6f6482560f6628b5aaeba39207c9aad9"
2027 | 


--------------------------------------------------------------------------------