bump: uuid

.gitea/workflows/tag_release.yml

@@ -17,7 +17,7 @@ jobs:
       - name: Install Rust
         uses: actions-rs/toolchain@v1
         with:
-          toolchain: 1.96.1
+          toolchain: 1.97
           components: cargo
 
       - name: Extract Version from Cargo.toml

.gitea/workflows/workflow.yml

@@ -20,7 +20,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.96.1
+          toolchain: 1.97
       - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh
@@ -39,7 +39,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.96.1
+          toolchain: 1.97
       - uses: Swatinem/rust-cache@v2
       - run: rustup component add rustfmt
       - run: |
@@ -59,7 +59,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.96.1
+          toolchain: 1.97
       - uses: Swatinem/rust-cache@v2
       - run: rustup component add clippy
       - run: |
@@ -79,7 +79,7 @@ jobs:
       - uses: actions/checkout@v6
       - uses: actions-rust-lang/setup-rust-toolchain@v1
         with:
-          toolchain: 1.96.1
+          toolchain: 1.97
       - uses: Swatinem/rust-cache@v2
       - run: |
           mkdir -p ~/.ssh

Cargo.lock

@@ -567,40 +567,6 @@ dependencies = [
  "windows-registry",
 ]
 
-[[package]]
-name = "icarus_envy"
-version = "0.8.0"
-source = "git+ssh://git@git.kundeng.us/phoenix/icarus_envy.git?tag=v0.8.0#349056db6e6254c2eb778fdcdd1d64de339f1309"
-dependencies = [
- "const_format",
- "dotenvy",
-]
-
-[[package]]
-name = "icarus_meta"
-version = "0.6.1"
-source = "git+ssh://git@git.kundeng.us/phoenix/icarus_meta.git?tag=v0.6.1#946c46a23b387323c20720cd78bbac3c34595854"
-dependencies = [
- "imghdr",
- "infer",
- "lofty",
- "rand",
-]
-
-[[package]]
-name = "icarus_models"
-version = "0.11.3"
-source = "git+ssh://git@git.kundeng.us/phoenix/icarus_models.git?tag=v0.11.3#859b0fb1b377370d8171e22e59893d86e41b258b"
-dependencies = [
- "josekit",
- "rand",
- "serde",
- "serde_json",
- "time",
- "utoipa",
- "uuid",
-]
-
 [[package]]
 name = "icu_collections"
 version = "2.2.0"
@@ -1485,6 +1451,15 @@ version = "2.0.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f8fadd59c855ef2080decdef8ff161eb6661b86933c9d82e5ba29dc602a55aba"
 
+[[package]]
+name = "sienvy"
+version = "0.8.0"
+source = "git+ssh://git@git.kundeng.us/phoenix/sienvy.git?tag=v0.8.0-main-d06c8fdf49-006#d06c8fdf49920cf4d8ba0487c20f5bdc851c36de"
+dependencies = [
+ "const_format",
+ "dotenvy",
+]
+
 [[package]]
 name = "signal-hook-registry"
 version = "1.4.8"
@@ -1517,6 +1492,31 @@ version = "0.1.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3a9fe34e3e7a50316060351f37187a3f546bce95496156754b601a5fa71b76e"
 
+[[package]]
+name = "simeta"
+version = "0.6.1"
+source = "git+ssh://git@git.kundeng.us/phoenix/simeta.git?tag=v0.6.1-main-b690995806-680#b6909958064b1a3a4bffd6cbc0f6e12b95477e68"
+dependencies = [
+ "imghdr",
+ "infer",
+ "lofty",
+ "rand",
+]
+
+[[package]]
+name = "simodels"
+version = "0.11.3"
+source = "git+ssh://git@git.kundeng.us/phoenix/simodels.git?tag=v0.11.3-main-fe9d101bd0-111#fe9d101bd019f91fe8c99c29721ccb0e6e90c92c"
+dependencies = [
+ "josekit",
+ "rand",
+ "serde",
+ "serde_json",
+ "time",
+ "utoipa",
+ "uuid",
+]
+
 [[package]]
 name = "slab"
 version = "0.4.12"
@@ -1544,13 +1544,13 @@ name = "songparser"
 version = "0.6.1"
 dependencies = [
  "futures",
- "icarus_envy",
- "icarus_meta",
- "icarus_models",
  "openssl",
  "reqwest",
  "serde",
  "serde_json",
+ "sienvy",
+ "simeta",
+ "simodels",
  "time",
  "tokio",
  "uuid",
@@ -1884,9 +1884,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.23.4"
+version = "1.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bf80a72845275afea99e7f2b434723d3bc7e38470fcd1c7ed39a599c73319a53"
+checksum = "bf3923a6f5c4c6382e0b653c4117f48d631ea17f38ed86e2a828e6f7412f5239"
 dependencies = [
  "getrandom 0.4.3",
  "js-sys",

Cargo.toml

@@ -12,7 +12,7 @@ openssl = { version = "0.10.81", features = ["vendored"] }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { version = "1.0.150" }
 time = { version = "0.3.53", features = ["macros", "serde"] }
-uuid = { version = "1.23.4", features = ["v4", "serde"] }
+uuid = { version = "1.23.5", features = ["v4", "serde"] }
-icarus_meta = { git = "ssh://git@git.kundeng.us/phoenix/icarus_meta.git", tag = "v0.6.1" }
+simeta = { git = "ssh://git@git.kundeng.us/phoenix/simeta.git", tag = "v0.6.1-main-b690995806-680" }
-icarus_models = { git = "ssh://git@git.kundeng.us/phoenix/icarus_models.git", tag = "v0.11.3" }
+simodels = { git = "ssh://git@git.kundeng.us/phoenix/simodels.git", tag = "v0.11.3-main-fe9d101bd0-111" }
-icarus_envy = { git = "ssh://git@git.kundeng.us/phoenix/icarus_envy.git", tag = "v0.8.0" }
+sienvy = { git = "ssh://git@git.kundeng.us/phoenix/sienvy.git", tag = "v0.8.0-main-d06c8fdf49-006" }

README.md

@@ -1,4 +1,4 @@
-# Songparser
+# songparser
 A service that edits the metadata of a queued song and populates it with data.
 
 

src/api.rs

@@ -162,7 +162,7 @@ pub mod service_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::login_result::LoginResult>,
+            pub data: Vec<simodels::login_result::LoginResult>,
         }
     }
 }
@@ -172,7 +172,7 @@ pub mod refresh_token {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::login_result::LoginResult>,
+            pub data: Vec<simodels::login_result::LoginResult>,
         }
     }
 }
@@ -253,7 +253,7 @@ pub mod create_song {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::song::Song>,
+            pub data: Vec<simodels::song::Song>,
         }
     }
 }
@@ -261,7 +261,7 @@ pub mod create_song {
 pub mod create_coverart {
     pub async fn create(
         app: &crate::config::App,
-        song: &icarus_models::song::Song,
+        song: &simodels::song::Song,
         queued_coverart: &crate::queued_item::QueuedCoverArt,
     ) -> Result<reqwest::Response, reqwest::Error> {
         let client = reqwest::Client::builder().build()?;
@@ -284,7 +284,7 @@ pub mod create_coverart {
         #[derive(Debug, serde::Deserialize, serde::Serialize)]
         pub struct Response {
             pub message: String,
-            pub data: Vec<icarus_models::coverart::CoverArt>,
+            pub data: Vec<simodels::coverart::CoverArt>,
         }
     }
 }

src/auth/mod.rs

@@ -1,12 +1,12 @@
 pub async fn get_token(
     app: &crate::config::App,
-) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
+) -> Result<simodels::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/service/login");
     let api_url = format!("{}/{endpoint}", app.auth_uri);
 
     let payload = serde_json::json!({
-        "passphrase": icarus_envy::environment::get_service_passphrase().value,
+        "passphrase": sienvy::environment::get_service_passphrase().value,
     });
 
     match client.post(api_url).json(&payload).send().await {
@@ -29,7 +29,7 @@ pub async fn get_token(
 
 pub async fn get_refresh_token(
     app: &crate::config::App,
-) -> Result<icarus_models::login_result::LoginResult, std::io::Error> {
+) -> Result<simodels::login_result::LoginResult, std::io::Error> {
     let client = reqwest::Client::new();
     let endpoint = String::from("api/v2/token/refresh");
     let api_url = format!("{}/{endpoint}", app.auth_uri);

src/config.rs

@@ -2,7 +2,7 @@
 pub struct App {
     pub uri: String,
     pub auth_uri: String,
-    pub token: icarus_models::login_result::LoginResult,
+    pub token: simodels::login_result::LoginResult,
     pub root_directory: String,
 }
 
@@ -15,9 +15,9 @@ impl App {
 
 pub async fn initialize_app_config() -> App {
     App {
-        uri: icarus_envy::environment::get_icarus_base_api_url().value,
+        uri: sienvy::environment::get_icarus_base_api_url().value,
-        auth_uri: icarus_envy::environment::get_icarus_auth_base_api_url().value,
+        auth_uri: sienvy::environment::get_icarus_auth_base_api_url().value,
-        root_directory: icarus_envy::environment::get_root_directory().value,
+        root_directory: sienvy::environment::get_root_directory().value,
         ..Default::default()
     }
 }

src/metadata/mod.rs

@@ -5,101 +5,96 @@ pub async fn apply_metadata(
     metadata: &crate::api::get_metadata_queue::response::Metadata,
 ) -> Result<bool, std::io::Error> {
     // Apply metadata fields
-    let types = icarus_meta::types::all_metadata_types();
+    let types = simeta::types::all_metadata_types();
 
     for t in types {
         match t {
-            icarus_meta::types::Type::Album => {
+            simeta::types::Type::Album => {
-                let meta_type =
+                let meta_type = simeta::types::MetadataType::from_string(metadata.album.clone());
-                    icarus_meta::types::MetadataType::from_string(metadata.album.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::AlbumArtist => {
+            simeta::types::Type::AlbumArtist => {
                 let meta_type =
-                    icarus_meta::types::MetadataType::from_string(metadata.album_artist.clone());
+                    simeta::types::MetadataType::from_string(metadata.album_artist.clone());
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Artist => {
+            simeta::types::Type::Artist => {
-                let meta_type =
+                let meta_type = simeta::types::MetadataType::from_string(metadata.artist.clone());
-                    icarus_meta::types::MetadataType::from_string(metadata.artist.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Date => {
+            simeta::types::Type::Date => {
                 // TODO: Do something about this discrepancy
-                let meta_type =
+                let meta_type = simeta::types::MetadataType::from_string(metadata.year.to_string());
-                    icarus_meta::types::MetadataType::from_string(metadata.year.to_string());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Disc => {
+            simeta::types::Type::Disc => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc);
+                let meta_type = simeta::types::MetadataType::from_int(metadata.disc);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Genre => {
+            simeta::types::Type::Genre => {
-                let meta_type =
+                let meta_type = simeta::types::MetadataType::from_string(metadata.genre.clone());
-                    icarus_meta::types::MetadataType::from_string(metadata.genre.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Title => {
+            simeta::types::Type::Title => {
-                let meta_type =
+                let meta_type = simeta::types::MetadataType::from_string(metadata.title.clone());
-                    icarus_meta::types::MetadataType::from_string(metadata.title.clone());
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::Track => {
+            simeta::types::Type::Track => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track);
+                let meta_type = simeta::types::MetadataType::from_int(metadata.track);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::TrackCount => {
+            simeta::types::Type::TrackCount => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.track_count);
+                let meta_type = simeta::types::MetadataType::from_int(metadata.track_count);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
                     }
                 }
             }
-            icarus_meta::types::Type::DiscCount => {
+            simeta::types::Type::DiscCount => {
-                let meta_type = icarus_meta::types::MetadataType::from_int(metadata.disc_count);
+                let meta_type = simeta::types::MetadataType::from_int(metadata.disc_count);
-                match icarus_meta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
+                match simeta::meta::metadata::set_meta_value(t, &queued_song.path, meta_type) {
                     Ok(_) => {}
                     Err(_err) => {
                         return Err(_err);
@@ -110,11 +105,11 @@ pub async fn apply_metadata(
     }
 
     // Apply coverart
-    match icarus_meta::meta::coverart::contains_coverart(&queued_song.path) {
+    match simeta::meta::coverart::contains_coverart(&queued_song.path) {
         Ok((exists, size)) => {
             if exists {
                 println!("Coverart exists: {size:?} size");
-                match icarus_meta::meta::coverart::remove_coverart(&queued_song.path) {
+                match simeta::meta::coverart::remove_coverart(&queued_song.path) {
                     Ok(_data) => {}
                     Err(err) => {
                         return Err(err);
@@ -122,10 +117,7 @@ pub async fn apply_metadata(
                 }
             }
 
-            match icarus_meta::meta::coverart::set_coverart(
+            match simeta::meta::coverart::set_coverart(&queued_song.path, &queued_coverart.path) {
-                &queued_song.path,
-                &queued_coverart.path,
-            ) {
                 Ok(_data) => {
                     if _data.is_empty() {
                         println!("There was an issue");

src/parser/mod.rs

@@ -4,8 +4,8 @@ pub async fn some_work(
     user_id: &uuid::Uuid,
 ) -> Result<
     (
-        icarus_models::song::Song,
+        simodels::song::Song,
-        icarus_models::coverart::CoverArt,
+        simodels::coverart::CoverArt,
         crate::api::get_metadata_queue::response::Metadata,
         crate::queued_item::QueuedSong,
         crate::queued_item::QueuedCoverArt,
@@ -30,9 +30,8 @@ pub async fn some_work(
                                     println!("Updated queued song");
                                     println!("Response: {_inner_response:?}");
 
-                                    let song_type = String::from(
+                                    let song_type =
-                                        icarus_meta::detection::song::constants::FLAC_TYPE,
+                                        String::from(simeta::detection::song::constants::FLAC_TYPE);
-                                    );
 
                                     match crate::api::create_song::create(
                                         app, &metadata, user_id, &song_type,
@@ -104,10 +103,10 @@ pub async fn prep_song(
             // Process data here...
             match crate::api::parsing::parse_response_into_bytes(response).await {
                 Ok(song_bytes) => {
-                    let song = icarus_models::song::Song {
+                    let song = simodels::song::Song {
-                        directory: icarus_envy::environment::get_root_directory().value,
+                        directory: sienvy::environment::get_root_directory().value,
-                        filename: icarus_models::song::generate_filename(
+                        filename: simodels::song::generate_filename(
-                            icarus_models::types::MusicType::FlacExtension,
+                            simodels::types::MusicType::FlacExtension,
                             true,
                         )
                         .unwrap(),
@@ -223,18 +222,18 @@ async fn init_queued_coverart(
     bytes: Vec<u8>,
 ) -> crate::queued_item::QueuedCoverArt {
     // TODO: Consider separating song and coverart when saving to the filesystem
-    let covart_type = if file_type == icarus_meta::detection::coverart::constants::PNG_TYPE {
+    let covart_type = if file_type == simeta::detection::coverart::constants::PNG_TYPE {
-        icarus_models::types::CoverArtType::PngExtension
+        simodels::types::CoverArtType::PngExtension
-    } else if file_type == icarus_meta::detection::coverart::constants::JPEG_TYPE {
+    } else if file_type == simeta::detection::coverart::constants::JPEG_TYPE {
-        icarus_models::types::CoverArtType::JpegExtension
+        simodels::types::CoverArtType::JpegExtension
-    } else if file_type == icarus_meta::detection::coverart::constants::JPG_TYPE {
+    } else if file_type == simeta::detection::coverart::constants::JPG_TYPE {
-        icarus_models::types::CoverArtType::JpgExtension
+        simodels::types::CoverArtType::JpgExtension
     } else {
-        icarus_models::types::CoverArtType::None
+        simodels::types::CoverArtType::None
     };
-    let coverart = icarus_models::coverart::CoverArt {
+    let coverart = simodels::coverart::CoverArt {
-        directory: icarus_envy::environment::get_root_directory().value,
+        directory: sienvy::environment::get_root_directory().value,
-        filename: match icarus_models::coverart::generate_filename(covart_type, true) {
+        filename: match simodels::coverart::generate_filename(covart_type, true) {
             Ok(filename) => filename,
             Err(err) => {
                 eprintln!("Error generating CoverArt filename: {err:?}");
@@ -255,8 +254,8 @@ async fn init_queued_coverart(
 }
 
 pub async fn cleanup(
-    song: &icarus_models::song::Song,
+    song: &simodels::song::Song,
-    coverart: &icarus_models::coverart::CoverArt,
+    coverart: &simodels::coverart::CoverArt,
 ) -> Result<(), std::io::Error> {
     match song.remove_from_filesystem() {
         Ok(_) => {}

src/queued_item.rs

@@ -1,13 +1,13 @@
 #[derive(Clone, Debug, Default)]
 pub struct QueuedSong {
     pub id: uuid::Uuid,
-    pub song: icarus_models::song::Song,
+    pub song: simodels::song::Song,
     pub path: String,
 }
 
 #[derive(Clone, Debug, Default)]
 pub struct QueuedCoverArt {
     pub id: uuid::Uuid,
-    pub coverart: icarus_models::coverart::CoverArt,
+    pub coverart: simodels::coverart::CoverArt,
     pub path: String,
 }