updated documentation and added “None” option for image description

README.md

@@ -1,20 +1,63 @@
 # Instagram Pixelfed Batch Upload
 
-This program takes a folder and iterates over the images and creates Pixelfed postings with a specified batch size. 
-The description of the post can be given via the config.json. 
+![Tool illustration](assets/pixelfed-bot_illustration_small.png "Littel Robot describing the pictures for you.")
+
+This program takes a folder, iterates over the images and creates Pixelfed postings with a specified batch size. 
+
+There are 4 different options for the image description (ALT text) supported now:
+
+1. ChatGPT/OpenAI mode: generating the image description using the OpenAI API and respective model. You'll need to provide your OpenAI API access key and the model you wanna use. 
+
+2. Local/Ollama mode: generate the image description using a local/own installation of Ollama. You'll have to configure the base URL of your ollama installation, an (optional) access key and the model to be used.
+
+3.) File mode: reading the image description from a text file with the same name as the image + a configurable extension. 
+
+4.) No description: don't generate an image description, just batch upload the pictures.
+
+
+The description of the post can be given via the `config.json`. 
 Two variables in the post description can be give (see the `config.json.example` ).
 
-Usage: `./pixelfed_batch_uploader ../../Downloads/Instagram-Backup/media/posts/201406 --title "June 2014"`
+```
+Usage: pixelfed_batch_uploader [OPTIONS] --title <TITLE> --image-path <IMAGE_PATH>
+
+Options:
+  -m, --mode <MODE>
+          Image description mode
+
+          [default: file]
+
+          Possible values:
+          - chat-gpt: Use ChatGTP
+          - file:     Taking from a file
+          - local:    Local LLM
+          - none
+
+  -t, --title <TITLE>
+          The title of the posting
+
+  -i, --image-path <IMAGE_PATH>
+          The path to the file to read
+
+  -c, --config <FILE>
+          Sets a custom config file
+
+  -v, --visibility <private>
+
+
+  -h, --help
+          Print help (see a summary with '-h')
+
+  -V, --version
+          Print version
+```
+
+Example: `Usage: `./pixelfed_batch_uploader -i ../../Downloads/Instagram-Backup/media/posts/201406 --title "June 2014" -m local`
 
 The `config.json` must be in the same directory the program is called from (`$PWD`)
 
 
-[![asciicast](https://asciinema.mxhdr.net/a/6.svg)](https://asciinema.mxhdr.net/a/6)
-
 
 Check the [package of this repo](https://repos.mxhdr.net/maxheadroom/insta-import-pixelfed/packages) to get pre-compiled binaries for macOS (Apple Silicon), Linux x86_64, Windows ARM
 
 
-## OpenAI Integration for Image Description
-
-Added OpenAI integration to generate image descriptions and put them into the ALT text for each image. If an `openai_api_key` is present in the `config.json` then the Image description is fetched from the OpenAI API.

config.json.example

@@ -1,12 +1,15 @@
 {
-    "pixelfed_url":  "https://pixelfed.example.com",
-    // See https://docs.pixelfed.org/running-pixelfed/installation.html#setting-up-services
-      "access_token": "sdg;lkjrglksjh;lkshj;lksjthrst;hoijrt;ihj;sithj;itjh",
-    "visibility": "unlisted",
-    "batch_size": 10,
-    "default_text": "Instagram dump from @title@ @batch@  #instabackup #instaimport #instaexit",
-    // https://help.openai.com/en/articles/4936850-where-do-i-find-my-openai-api-key
-    "openai_api_key": "0bff275feca7baab5ac508e635543f59fff42d4436c9918cd37c330f9adb4eb4fda643c212794b800bb05fb26016f55425c6755a3525c64792197e4d0fbe95d5",
+    "pixelfed_url":  "https://pxl.mxhdr.net",
+    "pixelfed_access_token": "longstringofpersonalaccesstokenfromyourpixelfedaccount",
+    "pixelfed_visibility": "public",
+    "pixelfed_batch_size": 20,
+    "pixelfed_default_text": "Instagram dump from @title@ @batch@ #instabackup #instaimport #instaexit",
+    "openai_api_key": "youropenapiaccesskey",
     "openai_api_url": "https://api.openai.com/v1/chat/completions",
-    "openai_model": "gpt-4o"
+    "openai_model": "gpt-4o",
+    "ollama_api_key": "yourollamaaccesskey_mightbeoptional",
+    "ollama_api_url": "http://localhost:11434/api/generate",
+    "ollama_model": "llama3.2-vision:11b-instruct-q8_0",
+    "caption_extension": ".caption.txt",
+    "prompt": "Imagine you are posting on social media and want to provide image descriptions for people with vision disabilities. Those people might use screen readers. That’s why you want to put an ALT text for images so those people can understand what is shown in the picture. Try to detect the main topic and mood or intention of the picture. If there is visible and readable text in the image, then also provide that text. Complete the sentence: “This picture shows” and respond in plain text format with less than 5000 characters?"
 }

package.sh

@@ -1,6 +1,6 @@
 #!/bin/bash -x
 
-RELEASE_VERSION="1.0.3"
+RELEASE_VERSION="1.1.0"
 
 PLATFORM=$(rustc -vV | grep host | cut -d ' ' -f2)
 

src/image_description.rs

@@ -1,5 +1,5 @@
 use base64::{engine::general_purpose::STANDARD, Engine as _};
-use log::{debug, error, info, log_enabled, Level};
+use log::{debug, error, info};
 use serde::Deserialize;
 use serde::Serialize;
 use serde_json::json;
@@ -41,18 +41,27 @@ struct LlamaModel {
 pub fn get_description_from_file(
     image_name: String,
     file_config: FileConfig,
-) -> Result<String, Box<dyn super::Error>> {
+) -> Result<String, Box<dyn std::error::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);
+    let captionname = format!("{}{}", &image_name, caption_extension);
 
     debug!("Looking for {}", &captionname);
-    let caption_data = std::fs::read_to_string(captionname);
+    let caption_data = match std::fs::read_to_string(captionname) {
+        Ok(caption) => caption,
+        Err(e) => {
+            error!("Failed to find caption file: {}", &e.to_string());
+            std::process::exit(1);
+        }
+    };
 
-    println!("Description fetched successfully from FILE");
+    println!(
+        "Description fetched successfully from FILE for {}",
+        &image_name
+    );
 
-    Ok(caption_data.unwrap())
+    Ok(caption_data)
 }
 
 // fetch image description from ChatGPT
@@ -61,7 +70,7 @@ pub fn get_description_from_chatgpt(
     chatgpt_config: self::ChatGPTConfig,
 ) -> Result<String, Box<dyn super::Error>> {
     // Read and encode image
-    let image_data = std::fs::read(image_name)?;
+    let image_data = std::fs::read(&image_name)?;
 
     // Base64 encode the image for ChatGTP API
     let base64_image = STANDARD.encode(image_data);
@@ -112,7 +121,10 @@ pub fn get_description_from_chatgpt(
         .as_str()
         .ok_or("Invalid content format in response")?
         .to_string();
-    println!("Description generated successfully from ChatGPT");
+    println!(
+        "Description generated successfully from ChatGPT for {}",
+        &image_name
+    );
 
     Ok(description)
 }
@@ -123,7 +135,7 @@ pub fn get_description_from_ollama(
     ollama_config: OllamaConfig,
 ) -> Result<String, Box<dyn super::Error>> {
     // Read and encode image
-    let image_data = std::fs::read(image_name)?;
+    let image_data = std::fs::read(&image_name)?;
     // Base64 encode the image for ChatGTP API
     let base64_image = STANDARD.encode(image_data);
 
@@ -179,6 +191,9 @@ pub fn get_description_from_ollama(
     };
 
     info!("Description generated by OLLAMA: {}", &description);
-    println!("Description generated successfully from OLLAMA");
+    println!(
+        "Description generated successfully from OLLAMA for {}",
+        &image_name
+    );
     Ok(description)
 }

src/main.rs

@@ -1,16 +1,15 @@
-use std::fs;
+use clap::{Parser, ValueEnum};
+use log::info;
 use serde::Deserialize;
 use serde_json::{json, Value};
 use std::error::Error;
+use std::fs;
 use std::fs::File;
 use std::io::BufReader;
-use clap::{Parser, ValueEnum};
 use std::path::PathBuf;
-use log::{debug, error, log_enabled, info, Level};
 
-
-mod pixelfed;
 pub mod image_description;
+mod pixelfed;
 
 #[derive(Parser)]
 #[command(name = "Pixelfed Image Bulk Uploader")]
@@ -35,7 +34,6 @@ struct Cli {
     visibility: Option<String>,
 }
 
-
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum)]
 enum Mode {
     /// Use ChatGTP
@@ -44,14 +42,15 @@ enum Mode {
     File,
     /// Local LLM
     Local,
+    // No Image Description
+    None,
 }
 
-
 #[derive(Debug, Deserialize)]
 struct Config {
     pixelfed_url: String,
     pixelfed_access_token: String,
-    pixelfed_visibility: String,  // Should be "unlisted"
+    pixelfed_visibility: String, // Should be "unlisted"
     pixelfed_default_text: String,
     pixelfed_batch_size: usize,
     openai_api_key: String,
@@ -61,8 +60,7 @@ struct Config {
     ollama_api_url: String,
     ollama_model: String,
     caption_extension: String,
-    prompt:  String,
-    
+    prompt: String,
 }
 
 fn load_config(config_file: String) -> Result<Config, Box<dyn Error>> {
@@ -74,12 +72,10 @@ fn load_config(config_file: String) -> Result<Config, Box<dyn Error>> {
 
     // Read the JSON contents of the file as an instance of `User`.
 
-
     let config: Config = serde_json::from_reader(reader)?;
     Ok(config)
 }
 
-
 // get all the JPEG files from the give directory
 fn get_jpeg_files(directory: &str) -> Vec<String> {
     let mut images = Vec::new();
@@ -96,9 +92,7 @@ fn get_jpeg_files(directory: &str) -> Vec<String> {
     images
 }
 
-
-
- fn main() -> Result<(), Box<dyn Error>> {
+fn main() -> Result<(), Box<dyn Error>> {
     env_logger::init();
 
     let args = Cli::parse();
@@ -109,45 +103,51 @@ fn get_jpeg_files(directory: &str) -> Vec<String> {
     //    std::process::exit(1);
     //}
 
-    let  title = args.title;
-    let mut my_config: String;
-    
-    
+    let title = args.title;
+    let my_config: String;
 
     match args.config {
-        Some(configstring)  => { my_config = configstring}, 
-        None => {my_config = "config.json".to_string()},
-        
+        Some(configstring) => my_config = configstring,
+        None => my_config = "config.json".to_string(),
     }
     info!("effective config file: {}", &my_config);
 
-    
     let mut config = load_config(my_config).unwrap();
 
-     info!("Config OK?: " );
+    info!("Config OK?: ");
 
     // Overwrite config values with command line arguments
     match args.visibility {
-        Some(visibility)  => { config.pixelfed_visibility = visibility}, 
+        Some(visibility) => config.pixelfed_visibility = visibility,
         None => {}
     }
 
-    
-    
-    
     // get list of all the images in the gives path
     let images = get_jpeg_files(&args.image_path);
     info!("Images empty? {}", &images.is_empty().to_string());
 
     // knowing now the total number of images, calculate the number of batches
-    let total_batches = (images.len() + config.pixelfed_batch_size - 1) / config.pixelfed_batch_size;
-    println!("Found a total of {} images to upload. Will take {} batches", &images.len(), &total_batches);
+    let total_batches =
+        (images.len() + config.pixelfed_batch_size - 1) / config.pixelfed_batch_size;
+    println!(
+        "Found a total of {} images to upload. Will take {} batches",
+        &images.len(),
+        &total_batches
+    );
 
     // now iterate over all images in batches of batch_size
     for (i, chunk) in images.chunks(config.pixelfed_batch_size).enumerate() {
         info!("{}", i.clone());
-        let _ =pixelfed::bulk_upload_images(&config, chunk, i + 1, total_batches, &title, &args.mode);
+        match pixelfed::bulk_upload_images(&config, chunk, i + 1, total_batches, &title, &args.mode)
+        {
+            Ok(_) => {
+                println!("Upload of batch {} suceeded", &i + 1);
+            }
+            Err(e) => {
+                println!("Upload of batch {} failed: {}", &i + 1, e.to_string());
+            }
+        };
     }
-    println!("All images uploaded successfully.");
+    // println!("All images uploaded successfully.");
     Ok(())
 }

src/pixelfed.rs

@@ -1,5 +1,6 @@
-use log::{debug, error, info, log_enabled, Level};
+use log::{debug, error, info};
 use reqwest::{self};
+
 use std::error::Error;
 use std::time::Duration;
 
@@ -8,7 +9,6 @@ struct PixelfedConfig {
     pixelfed_access_token: String,
     pixelfed_visibility: String, // Should be "unlisted"
     pixelfed_default_text: String,
-    pixelfed_batch_size: usize,
 }
 
 fn format_post_text(template: &str, batch_num: usize, total_batches: usize, title: &str) -> String {
@@ -38,27 +38,25 @@ pub fn bulk_upload_images(
         pixelfed_access_token: config.pixelfed_access_token.clone(),
         pixelfed_visibility: config.pixelfed_visibility.clone(),
         pixelfed_default_text: config.pixelfed_default_text.clone(),
-        pixelfed_batch_size: config.pixelfed_batch_size.clone(),
     };
 
+    let client = match reqwest::blocking::ClientBuilder::new()
+        .connect_timeout(Duration::new(30, 0))
+        .timeout(Duration::new(300, 0))
+        .connection_verbose(true)
+        .build()
+    {
+        Ok(client) => client,
+        Err(e) => {
+            error!("Failed to build HTTP client: {}", e);
+            return Err(Box::from(e));
+        }
+    };
     // construct the full URL for the Pixelfed Upload
     let url = format!("{}/api/v1/media", pxl_config.pixelfed_url.clone());
 
     // Iterate over all the images we were given
     for image_path in images {
-        let client = match reqwest::blocking::ClientBuilder::new()
-            .connect_timeout(Duration::new(30, 0))
-            .timeout(Duration::new(300, 0))
-            .connection_verbose(true)
-            .build()
-        {
-            Ok(client) => client,
-            Err(e) => {
-                error!("Failed to build HTTP client: {}", e);
-                return Err(Box::from(e));
-            }
-        };
-
         let description: String;
         debug!("Handling image {}", &image_path.to_string());
         // get image description depending on the caption_mode
@@ -131,6 +129,11 @@ pub fn bulk_upload_images(
                 info!("Description generated by OLLAMA: {}", &description.clone());
                 media_descriptions.push(description.clone());
             }
+            super::Mode::None => {
+                // No impage description wanted
+                description = "".to_string();
+                media_descriptions.push(description.clone())
+            }
         }
 
         println!("Uploading image {} to Pixelfed", &image_path.to_string());
@@ -148,49 +151,35 @@ pub fn bulk_upload_images(
         };
 
         // upload the form to Pixelfed
-        let res = client
+        let res = match client
             .post(&url)
             .bearer_auth(&pxl_config.pixelfed_access_token)
             .multipart(form)
-            .send();
-
-        let res_json: serde_json::Value = match res {
-            Ok(response) => {
-                if response.status().is_success() {
-                    let rsp: serde_json::Value = response.json()?;
-                    info!("Image uploaded successfully! {}", &rsp.to_string());
-                    rsp.into()
-                } else {
-                    error!("Failed to upload image. Status: {:?}", &response.status());
-                    let error_message = response
-                        .text()
-                        .unwrap_or_else(|_| "Unknown error".to_string());
-                    error!("Error message: {}", error_message);
-                    return Err(Box::from("Failed to upload image"));
-                }
-            }
+            .send()
+        {
+            Ok(result) => result,
             Err(e) => {
                 error!("Failed to send request: {}", e);
                 return Err(Box::from(e));
             }
         };
 
-        let image_id = res_json["id"].as_str().unwrap().to_string();
-        media_ids.push(image_id);
+        let status = res.status();
+
+        // Check if the response status indicates success
+        if status.is_success() {
+            // Parse the success response
+            let success_response: serde_json::Value = res.json()?;
+            let image_id = success_response["id"].clone();
+            media_ids.push(image_id);
+        } else {
+            let error_text = res.text()?;
+            return Err(Box::from(format!("Failed to upload image: {}", error_text)));
+        }
     }
 
-    let client = match reqwest::blocking::ClientBuilder::new()
-        .connect_timeout(Duration::new(30, 0))
-        .timeout(Duration::new(300, 0))
-        .connection_verbose(true)
-        .build()
-    {
-        Ok(client) => client,
-        Err(e) => {
-            error!("Failed to build HTTP client: {}", e);
-            return Err(Box::from(e));
-        }
-    };
+    println!("Done uploading all images: {}", media_ids.len());
+
     if !media_ids.is_empty() {
         let post_url = format!("{}/api/v1/statuses", pxl_config.pixelfed_url);
         let post_text = format_post_text(
@@ -199,11 +188,12 @@ pub fn bulk_upload_images(
             total_batches,
             title,
         );
+
         let body = serde_json::json!({
-            "status": post_text,
+            "status": post_text.to_string(),
             "media_ids": media_ids,
             "alt_texts": media_descriptions,
-            "visibility": pxl_config.pixelfed_visibility,
+            "visibility": pxl_config.pixelfed_visibility.to_string(),
         });
         info!("Body: \n{}", &body.to_string());
         info!("MediaIDs: {}", &media_ids.len());