working version now without the async code.

src/image_description.rs

@@ -22,31 +22,31 @@ pub struct FileConfig {
 }
 
 // fetch the imagedescription from a file named like the Image 
-pub async fn get_description_from_file(image_name: String , file_config: FileConfig) -> Result<String, Box<dyn super::Error>>  {
+pub  fn get_description_from_file(image_name: String , file_config: FileConfig) -> Result<String, Box<dyn super::Error>>  {
     //read image caption from a local file that 
     //has the same name than the image with the extension ".caption.txt"
     let caption_extension = file_config.caption_extension;
     let captionname =   format!("{}{}", image_name, caption_extension);
     
     println!("Looking for {}",captionname);
-    let caption_data = tokio::fs::read_to_string(captionname).await.map_err(|e| format!("Failed to read caption from file: {}", e))?;
+    let caption_data = std::fs::read_to_string(captionname);
     
-    Ok(caption_data)
+    
+    Ok(caption_data.unwrap())
 }
 
 // fetch image description from ChatGPT
-pub async fn get_description_from_chatgpt(image_name: String, chatgpt_config: self::ChatGPTConfig) -> Result<String, Box<dyn super::Error>> {
+pub  fn get_description_from_chatgpt(image_name: String, chatgpt_config: self::ChatGPTConfig) -> Result<String, Box<dyn super::Error>> {
     // Read and encode image
-    let image_data = tokio::fs::read(image_name)
+    let image_data = std::fs::read(image_name)?;
-        .await
+        
-        .map_err(|e| format!("Failed to read image file: {}", e))?;
     
     
     // Base64 encode the image for ChatGTP API
     let base64_image = STANDARD.encode(image_data);
     
     // Create ChatGPT API request
-    let client = reqwest::Client::new();
+    let client = reqwest::blocking::Client::new();
     let response = client
         .post(chatgpt_config.openai_api_url)
         .header("Authorization", format!("Bearer {}", chatgpt_config.openai_api_key))
@@ -72,16 +72,15 @@ pub async fn get_description_from_chatgpt(image_name: String, chatgpt_config: se
                             }
                             ]
                             }))
-                            .send()
+                            .send();
-                            .await?;
                             
                             // Improved error handling for API response
-                            if !response.status().is_success() {
+                            //if !response.unwrap().status().is_success() {
-                            let error_text = response.text().await?;
+                            //    let error_text = response.unwrap_err();
-                            return Err(format!("OpenAI API error: {}", error_text).into());
+                            //    return Err(format!("OpenAI API error: ", std::error.box(error_text));
-                            }
+                            //}
                             
-                            let result: super::Value = response.json().await?;
+                            let result: super::Value = response.unwrap().json()?;
                             
                             // More detailed error handling for JSON parsing
                             let description = result["choices"]
@@ -96,6 +95,6 @@ pub async fn get_description_from_chatgpt(image_name: String, chatgpt_config: se
 }
 
 // fetch images description from own OLLAMA server
-pub async fn get_description_from_ollama(image_name: String, ollama_config: OllamaConfig) -> Result<String, Box<dyn super::Error>> {
+pub  fn get_description_from_ollama(image_name: String, ollama_config: OllamaConfig) -> Result<String, Box<dyn super::Error>> {
     Ok("Not implemented yet".to_string())
 }

src/main.rs

@@ -1,13 +1,10 @@
 use std::fs;
 use serde::Deserialize;
 use serde_json::{json, Value};
-use reqwest::blocking::Client;
-use reqwest::{self};
 use std::error::Error;
 use std::fs::File;
 use std::io::BufReader;
 use clap::{Parser, ValueEnum};
-use base64::{Engine as _, engine::general_purpose::STANDARD};
 use std::path::PathBuf;
 
 mod pixelfed;
@@ -94,8 +91,8 @@ fn get_jpeg_files(directory: &str) -> Vec<String> {
 }
 
 
-#[tokio::main]
+
-async fn main() -> Result<(), Box<dyn Error>> {
+ fn main() -> Result<(), Box<dyn Error>> {
     let args = Cli::parse();
     
     //if args.len() < 2 || args.len() > 3 {
@@ -135,7 +132,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
     // now iterate over all images in batches of batch_size 
     for (i, chunk) in images.chunks(config.pixelfed_batch_size).enumerate() {
         println!("{}", i.clone());
-        pixelfed::bulk_upload_images(&config, chunk, i + 1, total_batches, &title, &args.mode).await?;
+        pixelfed::bulk_upload_images(&config, chunk, i + 1, total_batches, &title, &args.mode);
     }
     println!("All images uploaded successfully.");
     Ok(())

src/pixelfed.rs

@@ -16,10 +16,10 @@ fn format_post_text(template: &str, batch_num: usize, total_batches: usize, titl
 }
 
 // upload a single image to pixelfed
-pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch_num: usize, total_batches: usize, title: &str, caption_mode: &super::Mode) -> Result<(), Box<dyn Error>> {
+pub fn bulk_upload_images(config: &super::Config, images: &[String], batch_num: usize, total_batches: usize, title: &str, caption_mode: &super::Mode) -> Result<(), Box<dyn Error>> {
     let mut media_ids = Vec::new();
     let mut media_descriptions = Vec::new();
-    let client = reqwest::Client::new();
+    let client = reqwest::blocking::Client::new();
     let pxl_config = PixelfedConfig {
         pixelfed_url: config.pixelfed_url.clone(),
         pixelfed_access_token: config.pixelfed_access_token.clone(),
@@ -40,7 +40,7 @@ pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch
                     openai_api_key: config.openai_api_key.clone(),
                     openai_api_url: config.openai_api_url.clone(),
                 };
-                description = super::image_description::get_description_from_chatgpt(image_path.to_string(), im_config).await?;
+                description = super::image_description::get_description_from_chatgpt(image_path.to_string(), im_config)?;
                 media_descriptions.push(description.clone());
             },
             super::Mode::File => {
@@ -48,7 +48,7 @@ pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch
                     caption_extension: config.caption_extension.clone(),
                 };
                 println!("Fetching image description from File for {}", image_path.to_string());
-                description = super::image_description::get_description_from_file(image_path.to_string(), im_config).await?;
+                description = super::image_description::get_description_from_file(image_path.to_string(), im_config)?;
                 media_descriptions.push(description.clone());
             },
             super::Mode::Local => {
@@ -58,7 +58,7 @@ pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch
                     ollama_model: config.ollama_model.clone(),
                 };
                 println!("Fetching image description from OLLAMA for {}", image_path.to_string());
-                description = super::image_description::get_description_from_ollama(image_path.to_string(), im_config).await?;
+                description = super::image_description::get_description_from_ollama(image_path.to_string(), im_config)?;
                 media_descriptions.push(description.clone());
             },
         }
@@ -66,16 +66,15 @@ pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch
         println!("Uploading image {}", image_path.to_string());
 
         // construct the upload form for Pixelfed Upload of a single image including image description
-        let form = multipart::Form::new()
+        let form = reqwest::blocking::multipart::Form::new().text("description", description.clone())
-            .file("file", image_path).await?;
+            .file("file", image_path)?;
         // upload the form to Pixelfed
         let res = client.post(&url)
             .bearer_auth(&config.pixelfed_access_token)
             .multipart(form)
-            .send()
+            .send();
-            .await?;
 
-        let res_json: serde_json::Value = res.json().await?;
+        let res_json: serde_json::Value = res.unwrap().json()?;
         let image_id = res_json["id"].as_str().unwrap().to_string();
         media_ids.push(image_id);
     }
@@ -96,7 +95,7 @@ pub async fn bulk_upload_images(config: &super::Config, images: &[String], batch
         client.post(&post_url)
             .bearer_auth(&config.pixelfed_access_token)
             .json(&body)
-            .send().await?;
+            .send();
     }
     Ok(())
 }