Add relative episode number to format

crunchy-cli-core/src/cli/archive.rs

@@ -4,7 +4,7 @@ use crate::cli::utils::{
     interactive_season_choosing, FFmpegPreset,
 };
 use crate::utils::context::Context;
-use crate::utils::format::{format_path, Format};
+use crate::utils::format::Format;
 use crate::utils::log::progress;
 use crate::utils::os::{free_file, has_ffmpeg, is_special_file, tempfile};
 use crate::utils::parse::{parse_url, UrlFilter};
@@ -243,16 +243,17 @@ impl Execute for Archive {
             for (formats, mut subtitles) in archive_formats {
                 let (primary, additionally) = formats.split_first().unwrap();
 
-                let path = free_file(format_path(
+                let path = free_file(
+                    primary.format_path(
                         if self.output.is_empty() {
                             "{title}.mkv"
                         } else {
                             &self.output
                         }
                         .into(),
-                    &primary,
                         true,
-                ));
+                    ),
+                );
 
                 info!(
                     "Downloading {} to '{}'",
@@ -395,7 +396,9 @@ async fn formats_from_series(
     let mut result: BTreeMap<u32, BTreeMap<u32, (Vec<Format>, Vec<Subtitle>)>> = BTreeMap::new();
     let mut primary_season = true;
     for season in seasons {
-        for episode in season.episodes().await? {
+        let episodes = season.episodes().await?;
+
+        for episode in episodes.iter() {
             if !url_filter.is_episode_valid(
                 episode.metadata.episode_number,
                 episode.metadata.season_number,
@@ -434,7 +437,7 @@ async fn formats_from_series(
                 };
                 Some(subtitle)
             }));
-            formats.push(Format::new_from_episode(episode, stream));
+            formats.push(Format::new_from_episode(episode, &episodes, stream));
         }
 
         primary_season = false;

crunchy-cli-core/src/cli/download.rs

@@ -4,7 +4,7 @@ use crate::cli::utils::{
     interactive_season_choosing, FFmpegPreset,
 };
 use crate::utils::context::Context;
-use crate::utils::format::{format_path, Format};
+use crate::utils::format::Format;
 use crate::utils::log::progress;
 use crate::utils::os::{free_file, has_ffmpeg, is_special_file};
 use crate::utils::parse::{parse_url, UrlFilter};
@@ -16,6 +16,7 @@ use crunchyroll_rs::{
     Episode, Locale, Media, MediaCollection, Movie, MovieListing, Season, Series,
 };
 use log::{debug, error, info, warn};
+use std::borrow::Cow;
 use std::fs::File;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Stdio};
@@ -148,7 +149,7 @@ impl Execute for Download {
                         episode.metadata.season_title,
                         episode.metadata.series_title
                     );
-                    format_from_episode(&self, episode, &url_filter, false)
+                    format_from_episode(&self, &episode, &url_filter, None, false)
                         .await?
                         .map(|fmt| vec![fmt])
                 }
@@ -209,16 +210,17 @@ impl Execute for Download {
             }
 
             for format in formats {
-                let path = free_file(format_path(
+                let path = free_file(
+                    format.format_path(
                         if self.output.is_empty() {
                             "{title}.mkv"
                         } else {
                             &self.output
                         }
                         .into(),
-                    &format,
                         true,
-                ));
+                    ),
+                );
 
                 info!(
                     "Downloading {} to '{}'",
@@ -392,8 +394,11 @@ async fn formats_from_season(
 
     let mut formats = vec![];
 
-    for episode in season.episodes().await? {
-        if let Some(fmt) = format_from_episode(download, episode, url_filter, true).await? {
+    let episodes = season.episodes().await?;
+    for episode in episodes.iter() {
+        if let Some(fmt) =
+            format_from_episode(download, &episode, url_filter, Some(&episodes), true).await?
+        {
             formats.push(fmt)
         }
     }
@@ -403,8 +408,9 @@ async fn formats_from_season(
 
 async fn format_from_episode(
     download: &Download,
-    episode: Media<Episode>,
+    episode: &Media<Episode>,
     url_filter: &UrlFilter,
+    season_episodes: Option<&Vec<Media<Episode>>>,
     filter_audio: bool,
 ) -> Result<Option<Format>> {
     if filter_audio && episode.metadata.audio_locale != download.audio {
@@ -457,7 +463,21 @@ async fn format_from_episode(
         )
     };
 
-    Ok(Some(Format::new_from_episode(episode, stream)))
+    let season_eps = if Format::has_relative_episodes_fmt(&download.output) {
+        if let Some(eps) = season_episodes {
+            Cow::from(eps)
+        } else {
+            Cow::from(episode.season().await?.episodes().await?)
+        }
+    } else {
+        Cow::from(vec![])
+    };
+
+    Ok(Some(Format::new_from_episode(
+        episode,
+        &season_eps.to_vec(),
+        stream,
+    )))
 }
 
 async fn format_from_movie_listing(
@@ -515,7 +535,7 @@ async fn format_from_movie(
         }
     };
 
-    Ok(Some(Format::new_from_movie(movie, stream)))
+    Ok(Some(Format::new_from_movie(&movie, stream)))
 }
 
 fn some_vec_or_none<T>(v: Vec<T>) -> Option<Vec<T>> {

crunchy-cli-core/src/utils/format.rs

@@ -1,5 +1,6 @@
 use crunchyroll_rs::media::VariantData;
 use crunchyroll_rs::{Episode, Locale, Media, Movie};
+use log::warn;
 use std::path::PathBuf;
 use std::time::Duration;
 
@@ -22,35 +23,56 @@ pub struct Format {
 
     pub episode_id: String,
     pub episode_number: f32,
+    pub relative_episode_number: f32,
 }
 
 impl Format {
-    pub fn new_from_episode(episode: Media<Episode>, stream: VariantData) -> Self {
+    pub fn new_from_episode(
+        episode: &Media<Episode>,
+        season_episodes: &Vec<Media<Episode>>,
+        stream: VariantData,
+    ) -> Self {
         Self {
-            title: episode.title,
-            description: episode.description,
+            title: episode.title.clone(),
+            description: episode.description.clone(),
 
-            audio: episode.metadata.audio_locale,
+            audio: episode.metadata.audio_locale.clone(),
 
             duration: episode.metadata.duration.to_std().unwrap(),
             stream,
 
-            series_id: episode.metadata.series_id,
-            series_name: episode.metadata.series_title,
+            series_id: episode.metadata.series_id.clone(),
+            series_name: episode.metadata.series_title.clone(),
 
-            season_id: episode.metadata.season_id,
-            season_title: episode.metadata.season_title,
-            season_number: episode.metadata.season_number,
+            season_id: episode.metadata.season_id.clone(),
+            season_title: episode.metadata.season_title.clone(),
+            season_number: episode.metadata.season_number.clone(),
 
-            episode_id: episode.id,
-            episode_number: episode.metadata.episode.parse().unwrap_or(episode.metadata.sequence_number),
+            episode_id: episode.id.clone(),
+            episode_number: episode
+                .metadata
+                .episode
+                .parse()
+                .unwrap_or(episode.metadata.sequence_number),
+            relative_episode_number: season_episodes
+                .iter()
+                .enumerate()
+                .find_map(|(i, e)| if e == episode { Some((i + 1) as f32) } else { None })
+                .unwrap_or_else(|| {
+                    warn!("Cannot find relative episode number for episode {} ({}) of season {} ({}) of {}, using normal episode number", episode.metadata.episode_number, episode.title, episode.metadata.season_number, episode.metadata.season_title, episode.metadata.series_title);
+                    episode
+                        .metadata
+                        .episode
+                        .parse()
+                        .unwrap_or(episode.metadata.sequence_number)
+                }),
         }
     }
 
-    pub fn new_from_movie(movie: Media<Movie>, stream: VariantData) -> Self {
+    pub fn new_from_movie(movie: &Media<Movie>, stream: VariantData) -> Self {
         Self {
-            title: movie.title,
-            description: movie.description,
+            title: movie.title.clone(),
+            description: movie.description.clone(),
 
             audio: Locale::ja_JP,
 
@@ -60,19 +82,19 @@ impl Format {
             series_id: movie.metadata.movie_listing_id.clone(),
             series_name: movie.metadata.movie_listing_title.clone(),
 
-            season_id: movie.metadata.movie_listing_id,
-            season_title: movie.metadata.movie_listing_title,
+            season_id: movie.metadata.movie_listing_id.clone(),
+            season_title: movie.metadata.movie_listing_title.clone(),
             season_number: 1,
 
-            episode_id: movie.id,
+            episode_id: movie.id.clone(),
             episode_number: 1.0,
-        }
+            relative_episode_number: 1.0,
         }
     }
 
     /// Formats the given string if it has specific pattern in it. It's possible to sanitize it which
     /// removes characters which can cause failures if the output string is used as a file name.
-pub fn format_path(path: PathBuf, format: &Format, sanitize: bool) -> PathBuf {
+    pub fn format_path(&self, path: PathBuf, sanitize: bool) -> PathBuf {
         let sanitize_func = if sanitize {
             |s: &str| sanitize_filename::sanitize(s)
         } else {
@@ -84,29 +106,41 @@ pub fn format_path(path: PathBuf, format: &Format, sanitize: bool) -> PathBuf {
 
         PathBuf::from(
             as_string
-            .replace("{title}", &sanitize_func(&format.title))
-            .replace("{audio}", &sanitize_func(&format.audio.to_string()))
+                .replace("{title}", &sanitize_func(&self.title))
+                .replace("{audio}", &sanitize_func(&self.audio.to_string()))
                 .replace(
                     "{resolution}",
-                &sanitize_func(&format.stream.resolution.to_string()),
+                    &sanitize_func(&self.stream.resolution.to_string()),
                 )
-            .replace("{series_id}", &sanitize_func(&format.series_id))
-            .replace("{series_name}", &sanitize_func(&format.series_name))
-            .replace("{season_id}", &sanitize_func(&format.season_id))
-            .replace("{season_name}", &sanitize_func(&format.season_title))
+                .replace("{series_id}", &sanitize_func(&self.series_id))
+                .replace("{series_name}", &sanitize_func(&self.series_name))
+                .replace("{season_id}", &sanitize_func(&self.season_id))
+                .replace("{season_name}", &sanitize_func(&self.season_title))
                 .replace(
                     "{season_number}",
-                &sanitize_func(&format.season_number.to_string()),
+                    &sanitize_func(&self.season_number.to_string()),
                 )
                 .replace(
                     "{padded_season_number}",
-                &sanitize_func(&format!("{:0>2}", format.season_number.to_string())),
+                    &sanitize_func(&format!("{:0>2}", self.season_number.to_string())),
+                )
+                .replace("{episode_id}", &sanitize_func(&self.episode_id))
+                .replace(
+                    "{episode_number}",
+                    &sanitize_func(&self.episode_number.to_string()),
                 )
-            .replace("{episode_id}", &sanitize_func(&format.episode_id))
-            .replace("{episode_number}", &sanitize_func(&format.episode_number.to_string()))
                 .replace(
                     "{padded_episode_number}",
-                &sanitize_func(&format!("{:0>2}", format.episode_number.to_string())),
+                    &sanitize_func(&format!("{:0>2}", self.episode_number.to_string())),
+                )
+                .replace(
+                    "{relative_episode_number}",
+                    &sanitize_func(&format!("{:0>2}", self.relative_episode_number.to_string())),
                 ),
         )
     }
+
+    pub fn has_relative_episodes_fmt<S: AsRef<str>>(s: S) -> bool {
+        return s.as_ref().contains("{relative_episode_number}");
+    }
+}