Add user shell commands after phases

Author: Assistant

Cargo.lock

@@ -20,6 +20,7 @@ fancy-regex = "0.14.0"
 reqwest = { version = "0.11.11", default-features = false, features = ["blocking", "json", "rustls-tls"] }
 serde = { version = "1.0.140", features = ["derive"] }
 serde_json = "1.0.82"
+strfmt = "0.2.4"
 terminal-spinners = "0.3.2"
 toml = "0.5.9"
 unicode-general-category = "1.0.0"

Cargo.toml

@@ -75,6 +75,14 @@ These are optional flags that affect how the program works.
 - `-v`, `--verbose`: Increases output, useful for debugging and reporting issues
 - `-V`, `--version`: Print version information [does not require `<TYPE>` or `<INPUT>`]
 
+These optional flags allow commands to be ran after each stage with variables wrapped in curly braces subtituted in.
+Supported variables are `{id}`, `{chat_ext}`, and `{video_title}`. Double curly braces for literals, e.g., `{{var}}` → `"{var}"`.
+- `-1`, `--post-json <SHELL_COMMAND>`: Runs after the json is downloaded
+- `-2`, `--post-thumbnail <SHELL_COMMAND>`: Runs after the thumbnail is downloaded
+- `-3`, `--post-chat <SHELL_COMMAND>`: Runs after the chat is downloaded
+- `-4`, `--post-chat-process <SHELL_COMMAND>`: Runs after the chat is processed
+- `-5`, `--post-video <SHELL_COMMAND>`: Runs after the video is downloaded
+
 These optional flags are only used when downloading Twitch Clips with both `--clips` and `--channel` options.
 - `-i <DURATION>`, `--interval <DURATION>`: Time interval to search for clips from a channel, shorter intervals will take longer but produce more complete results [default: `1hour`]
 - `-r <DURATION>`, `--range <DURATION>`: How long ago to start searching for clips [default: `1week`]

README.md

@@ -2,6 +2,7 @@
 , rustPlatform
 , installShellFiles
 , makeWrapper
+, bash
 , yt-dlp
 , brotli
 , twitch_downloader
@@ -39,7 +40,7 @@ in rustPlatform.buildRustPackage rec {
 
   postFixup = ''
     wrapProgram $out/bin/archiver \
-      --set PATH ${lib.makeBinPath [ yt-dlp brotli twitch_downloader python3Packages.chat-downloader twitch-chat-downloader ]}
+      --set PATH ${lib.makeBinPath [ bash yt-dlp brotli twitch_downloader python3Packages.chat-downloader twitch-chat-downloader ]}
   '';
 
   meta = with lib; {

package.nix

@@ -1,4 +1,4 @@
-use super::utils::colorize;
+use super::utils::{colorize, run_template};
 use crate::init::{Context, VideoType};
 use crate::utils::{
     download_file, error_msg, good_msg, message, sanitize, split_videos, warn_msg, write_file,
@@ -7,6 +7,7 @@ use crate::utils::{
 use crate::Error;
 use colored::Color;
 use fancy_regex::Regex;
+use std::collections::HashMap;
 use std::path::Path;
 
 pub(super) fn download<T: VideoInfo>(
@@ -29,6 +30,10 @@ pub(super) fn download<T: VideoInfo>(
         }
         VideoType::Clip => format!("{id}.mp4"),
     };
+    let mut vars = HashMap::new();
+    vars.insert("id".into(), id.into());
+    vars.insert("chat_ext".into(), chat_ext.into());
+    vars.insert("video_title".into(), video_title.clone());
 
     let spinner_text = format!(" Saving JSON {id}.json");
     context.spinner.create(&spinner_text);
@@ -40,6 +45,15 @@ pub(super) fn download<T: VideoInfo>(
             return Err(error);
         }
     }
+    if let Some(template) = &context.post_json {
+        context.spinner.create(" Running post_json");
+        let result = run_template(template, &vars);
+        context.spinner.end();
+        match result.is_ok() {
+            true => good_msg(Some("post_json"), "Success", context),
+            false => error_msg(Some("post_json"), "Failed", context),
+        }
+    }
 
     let spinner_text = format!(" Downloading {id}.jpg");
     context.spinner.create(&spinner_text);
@@ -52,6 +66,15 @@ pub(super) fn download<T: VideoInfo>(
         "Download",
         &format!("{id}.jpg"),
     );
+    if let Some(template) = &context.post_thumbnail {
+        context.spinner.create(" Running post_thumbnail");
+        let result = run_template(template, &vars);
+        context.spinner.end();
+        match result.is_ok() {
+            true => good_msg(Some("post_thumbnail"), "Success", context),
+            false => error_msg(Some("post_thumbnail"), "Failed", context),
+        }
+    }
 
     let spinner_text = format!(" Downloading {id}{chat_ext}");
     context.spinner.create(&spinner_text);
@@ -64,6 +87,15 @@ pub(super) fn download<T: VideoInfo>(
         "Download",
         &format!("{id}{chat_ext}"),
     );
+    if let Some(template) = &context.post_chat {
+        context.spinner.create(" Running post_chat");
+        let result = run_template(template, &vars);
+        context.spinner.end();
+        match result.is_ok() {
+            true => good_msg(Some("post_chat"), "Success", context),
+            false => error_msg(Some("post_chat"), "Failed", context),
+        }
+    }
 
     let spinner_text = format!(" Processing {id}{chat_ext}");
     context.spinner.create(&spinner_text);
@@ -76,13 +108,31 @@ pub(super) fn download<T: VideoInfo>(
         "Process",
         &format!("{id}{chat_ext}.br"),
     );
+    if let Some(template) = &context.post_chat_process {
+        context.spinner.create(" Running post_chat_process");
+        let result = run_template(template, &vars);
+        context.spinner.end();
+        match result.is_ok() {
+            true => good_msg(Some("post_chat_process"), "Success", context),
+            false => error_msg(Some("post_chat_process"), "Failed", context),
+        }
+    }
 
     if !context.skip_video {
         let spinner_text = format!(" Downloading {video_title}");
         context.spinner.create(&spinner_text);
         let result = get_video(info, context);
         context.spinner.end();
         parse_result(&result, context, "video", "Download", &video_title);
+        if let Some(template) = &context.post_video {
+            context.spinner.create(" Running post_video");
+            let result = run_template(template, &vars);
+            context.spinner.end();
+            match result.is_ok() {
+                true => good_msg(Some("post_video"), "Success", context),
+                false => error_msg(Some("post_video"), "Failed", context),
+            }
+        }
 
         message(
             &colorize(

src/downloader/common.rs

@@ -22,6 +22,7 @@ pub(crate) enum Error {
     Expected,
     Token(String),
     Config(String),
+    Template,
 }
 // todo!() Make better errors with information as to what went wrong
 
@@ -67,6 +68,12 @@ impl From<string::FromUtf8Error> for Error {
     }
 }
 
+impl From<strfmt::FmtError> for Error {
+    fn from(_: strfmt::FmtError) -> Error {
+        Error::Template
+    }
+}
+
 impl Display for Error {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         match self {
@@ -87,6 +94,7 @@ impl Display for Error {
             Error::CommandFailed(program) => write!(f, "Command failed: {program}"),
             Error::Expected => write!(f, "This error is expected"),
             Error::Token(message) | Error::Config(message) => write!(f, "{message}"),
+            Error::Template => write!(f, "Failed to run template"),
         }
     }
 }

src/downloader/error.rs

@@ -9,8 +9,9 @@ use std::fmt::{self, Debug, Display, Formatter};
 use std::fs::{File, OpenOptions};
 use std::io::Write;
 use std::path::Path;
-use std::process::Stdio;
+use std::process::{Command, Stdio};
 use std::sync::LazyLock;
+use strfmt::strfmt;
 use terminal_spinners::{SpinnerBuilder, SpinnerHandle, DOTS2};
 use unicode_general_category::{get_general_category, GeneralCategory};
 use unicode_normalization::UnicodeNormalization;
@@ -273,3 +274,17 @@ impl Spinner {
         self.message = None;
     }
 }
+
+pub(crate) fn run_template(template: &str, vars: &HashMap<String, String>) -> Result<(), Error> {
+    match Command::new("bash")
+        .arg("-c")
+        .arg(&strfmt(template, vars)?)
+        .stdout(Stdio::inherit())
+        .stderr(Stdio::inherit())
+        .status()?
+        .success()
+    {
+        true => Ok(()),
+        false => Err(Error::Template),
+    }
+}

src/downloader/utils.rs

@@ -13,6 +13,11 @@ pub(super) struct Args {
     pub(super) range: String,
     pub(super) interval: String,
     pub(super) threads: u16,
+    pub(super) post_json: Option<String>,
+    pub(super) post_thumbnail: Option<String>,
+    pub(super) post_chat: Option<String>,
+    pub(super) post_chat_process: Option<String>,
+    pub(super) post_video: Option<String>,
 }
 
 pub(super) fn parse() -> Args {
@@ -48,5 +53,10 @@ pub(super) fn parse() -> Args {
         cli.range,
         cli.interval,
         cli.threads,
+        cli.post_json,
+        cli.post_thumbnail,
+        cli.post_chat,
+        cli.post_chat_process,
+        cli.post_video,
     )
 }

src/init/args.rs

@@ -89,4 +89,24 @@ pub(crate) struct Cli {
     /// Hide spinners
     #[clap(short = 'q', long, takes_value = false)]
     pub(crate) hide_spinners: bool,
+
+    /// Template to run after the json is downloaded
+    #[clap(short = '1', long, value_name = "SHELL_COMMAND")]
+    pub(crate) post_json: Option<String>,
+
+    /// Template to run after the thumbnail is downloaded
+    #[clap(short = '2', long, value_name = "SHELL_COMMAND")]
+    pub(crate) post_thumbnail: Option<String>,
+
+    /// Template to run after chat is downloaded
+    #[clap(short = '3', long, value_name = "SHELL_COMMAND")]
+    pub(crate) post_chat: Option<String>,
+
+    /// Template to run after chat is processed
+    #[clap(short = '4', long, value_name = "SHELL_COMMAND")]
+    pub(crate) post_chat_process: Option<String>,
+
+    /// Template to run after the video is downloaded
+    #[clap(short = '5', long, value_name = "SHELL_COMMAND")]
+    pub(crate) post_video: Option<String>,
 }

src/init/cli.rs

@@ -80,6 +80,11 @@ pub(super) fn run() -> Result<Input, Error> {
         interval,
         logging: args.logging,
         spinner,
+        post_json: args.post_json,
+        post_thumbnail: args.post_thumbnail,
+        post_chat: args.post_chat,
+        post_chat_process: args.post_chat_process,
+        post_video: args.post_video,
     };
     Ok(Input::new(args.videos, context))
 }
@@ -118,6 +123,11 @@ pub(super) struct Context {
     pub(super) interval: Duration,
     pub(super) logging: bool,
     pub(super) spinner: Spinner,
+    pub(super) post_json: Option<String>,
+    pub(super) post_thumbnail: Option<String>,
+    pub(super) post_chat: Option<String>,
+    pub(super) post_chat_process: Option<String>,
+    pub(super) post_video: Option<String>,
 }
 
 fn parse_duration(text: &str) -> Duration {