ExifTool

https://docs.rs/exiftool/latest/
Admin
ExifTool is a Rust wrapper library for Phil Harvey’s ExifTool command-line application, enabling...
Tokens:37,231
Snippets:130
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Execute Custom ExifTool Commands in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Demonstrates how to run arbitrary ExifTool commands for advanced use cases not covered by convenience methods in rs-exiftool. It shows examples of getting output as text lines, raw bytes, and JSON, with input being a file path and command arguments. Dependencies include the exiftool crate.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let path = Path::new("image.jpg");
    let path_str = path.to_str().unwrap();

    // Get output as lines of text
    let lines = exiftool.execute_lines(&[
        "-S",  // Short output format
        "-DateTimeOriginal",
        "-Make",
        "-Model",
        path_str
    ])?;
    for line in lines {
        println!("{}", line);
    }

    // Get raw bytes (for binary operations)
    let raw_bytes = exiftool.execute_raw(&["-b", "-ThumbnailImage", path_str])?;
    println!("Raw output: {} bytes", raw_bytes.len());

    // Execute JSON command directly
    let json_value = exiftool.json_execute(&["-g2", "-GPS*", path_str])?;
    println!("GPS data: {}", json_value);

    Ok(())
}

```

--------------------------------

### Rust: Launch ExifTool with Default Path

Source: https://docs.rs/exiftool/latest/exiftool/struct

Shows how to create a new `ExifTool` instance using the default system path. This method searches for the `exiftool` executable in the system's `PATH` environment variable. Errors can occur if `exiftool` is not found or fails to start.

```rust
use exiftool::{ExifTool, ExifToolError};

let et = ExifTool::new()?;
println!("ExifTool process started successfully.");

```

--------------------------------

### Example Usage of ExifTool in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

This example demonstrates how to create an ExifTool instance in Rust and use it to read a specific tag from an image file. It shows basic error handling and the automatic cleanup of the exiftool process when the ExifTool instance goes out of scope.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn main() -> Result<(), ExifToolError> {
    // Create an ExifTool instance (launches the process)
    let mut et = ExifTool::new()?;

    // Use methods to interact with exiftool...
    let path = Path::new("image.jpg");
    let width: u32 = et.read_tag(path, "ImageWidth")?;
    println!("Width: {}", width);

    // The process is automatically closed when `et` goes out of scope
    // or explicitly via `drop(et)`.

    Ok(())
}
```

--------------------------------

### Rust: Launch ExifTool with Specific Executable Path

Source: https://docs.rs/exiftool/latest/exiftool/struct

Demonstrates launching `exiftool` from a specific executable path. This is useful when `exiftool` is not in the system's `PATH` or a particular version is required. The method returns an error if the path is invalid or the process fails to start.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

let path_to_exiftool = Path::new("/opt/local/bin/exiftool");
let et = ExifTool::with_executable(path_to_exiftool)?;
println!("ExifTool process started successfully from specific path.");

```

--------------------------------

### Launch ExifTool Process in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

This function launches the exiftool command-line process in stay-open mode, enabling persistent interaction. It sets up stdin, stdout, and stderr pipes for communication and returns an ExifTool struct to manage the process. Errors are handled if exiftool is not found or the process fails to start.

```rust
pub fn new() -> Result<Self, ExifToolError> {
    Self::with_executable(Path::new("exiftool"))
}
```

```rust
pub fn with_executable(exiftool_path: &Path) -> Result<Self, ExifToolError> {
    let mut command = Command::new(exiftool_path);

    command
        .arg("-stay_open")
        .arg("True")
        .arg("-@")
        .arg("-") // Read command args from stdin
        .stdin(Stdio::piped())
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    #[cfg(windows)]
    {
// ... (rest of the function)
    }
    // ... (process spawning and stderr thread setup)
}
```

--------------------------------

### Write and Verify Binary EXIF Tag (Rust)

Source: https://docs.rs/exiftool/latest/exiftool/struct

This snippet shows how to use rs_exiftool to write binary data to an EXIF tag (ThumbnailImage) and then read it back to verify the operation. It requires setting up a temporary image file and uses helper functions for setup and cleanup. The example overwrites the original tag.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::{Path, PathBuf};
use std::fs;


let temp_path = setup_temp_image("write_binary_test.jpg")?;
let mut et = ExifTool::new()?;

// Create some dummy binary data (e.g., a tiny placeholder thumbnail)
let new_thumbnail_bytes: Vec<u8> = vec![0xFF, 0xD8, 0xFF, 0xD9]; // Minimal valid JPEG

// Write the binary data to the ThumbnailImage tag, overwriting original
et.write_tag_binary(&temp_path, "ThumbnailImage", &new_thumbnail_bytes, &["-overwrite_original"])?;

// Read back to verify
let read_thumb = et.read_tag_binary(&temp_path, "ThumbnailImage")?;
assert_eq!(new_thumbnail_bytes, read_thumb);
println!("Successfully wrote and verified binary ThumbnailImage tag.");

cleanup_temp_image(&temp_path)?;
```

--------------------------------

### Execute ExifTool Command and Get Output Lines (Rust)

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Executes a command with exiftool and returns the standard output split into lines. It checks stderr for errors and logs warnings. This function is useful for retrieving simple text-based output from exiftool. It requires the `log` crate for warnings.

```rust
pub fn execute_lines(&mut self, args: &[&str]) -> Result<Vec<String>, ExifToolError> {
    let raw_output = self.execute_raw(args)?;
    let output_string = String::from_utf8(raw_output)?;
    Ok(output_string.lines().map(String::from).collect())
}
```

--------------------------------

### Read Common Metadata Tags with Grouping (Rust)

Source: https://docs.rs/exiftool/latest/exiftool/struct

Demonstrates reading common metadata tags and grouping them by family 1 (-g1) using the ExifTool::json method. This is useful for getting a broad overview of image metadata. It requires the 'exiftool' executable to be installed and accessible in the system's PATH. The output is a JSON string.

```rust
use exiftool::ExifTool;
use std::path::Path;

let mut exiftool = ExifTool::new()?;
let path = Path::new("data/image.jpg");

// Get common tags (-common) grouped by family 1 (-g1)
let result = exiftool.json(path, &["-g1", "-common"])?;

println!("Metadata: {}", result);
// Example output: {"SourceFile": "data/image.jpg", "EXIF": {...}, "XMP": {...}, ...}
```

--------------------------------

### Rust: Execute Raw ExifTool Command

Source: https://docs.rs/exiftool/latest/exiftool/struct

Provides an example of the low-level `execute_raw` method for executing a command with raw byte output. This method is generally not recommended for common use cases and is intended for scenarios requiring direct access to the process's byte streams. It handles sending arguments, waiting for `{ready}\n`, and checking stderr for errors.

```rust
pub fn execute_raw(&mut self, args: &[&str]) -> Result<Vec<u8>, ExifToolError>

```

--------------------------------

### Rust ExifTool: Deserializing Metadata

Source: https://docs.rs/exiftool/latest/index

Illustrates how to use the exiftool Rust library to read specific metadata tags and deserialize them directly into Rust structs using `serde`. This example shows reading partial metadata into a custom struct and reading a single tag into a string. It requires the `serde` crate for deserialization.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct ImageMetadata {
    #[serde(rename = "FileName")]
    file_name: String,
    #[serde(rename = "ImageWidth")]
    width: u32,
    #[serde(rename = "ImageHeight")]
    height: u32,
}

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let image_path = Path::new("path/to/your/image.jpg");

    // Read specific tags and deserialize into a struct
    let partial_meta: ImageMetadata = exiftool.read_tags(
        image_path,
        &["FileName", "ImageWidth", "ImageHeight"]
    )?;
    println!("Partial Metadata: {:?}", partial_meta);

    // Read a single tag and deserialize
    let author: String = exiftool.read_tag(image_path, "Author")?;
    println!("Author: {}", author);

    Ok(())
}

```

--------------------------------

### Comprehensive Error Handling in Rust with rs-exiftool

Source: https://context7.com/context7/rs_exiftool/llms.txt

Illustrates robust error handling for various failure scenarios when using the rs-exiftool library. It provides specific match arms for common errors like file not found, tag not found, deserialization errors, ExifTool not being installed, and process execution issues. The function returns a Result<(), ExifToolError> to propagate errors.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn process_image(path: &Path) -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;

    match exiftool.read_tag::<String>(path, "Make") {
        Ok(make) => println!("Camera: {}", make),
        Err(ExifToolError::FileNotFound { path, .. }) => {
            eprintln!("File not found: {:?}", path);
        }
        Err(ExifToolError::TagNotFound { tag, .. }) => {
            eprintln!("Tag '{}' not found in file", tag);
        }
        Err(ExifToolError::TagDeserialization { tag, error, .. }) => {
            eprintln!("Failed to deserialize tag '{}': {}", tag, error);
        }
        Err(ExifToolError::ExifToolNotFound(e)) => {
            eprintln!("ExifTool not installed: {}", e);
        }
        Err(ExifToolError::ExifToolProcess { message, std_err, .. }) => {
            eprintln!("ExifTool error: {}\nStderr: {}", message, std_err);
        }
        Err(ExifToolError::ProcessTerminated) => {
            eprintln!("ExifTool process terminated unexpectedly");
        }
        Err(e) => eprintln!("Other error: {:?}", e),
    }

    Ok(())
}

fn main() -> Result<(), ExifToolError> {
    process_image(Path::new("test.jpg"))
}

```

--------------------------------

### Execute ExifTool Command and Get JSON Output (Rust)

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Executes a command with exiftool using the `-json` argument and parses the output into a `serde_json::Value`. This function is ideal for structured metadata extraction. It handles potential errors during command execution and JSON parsing. It requires the `serde_json` crate.

```rust
pub fn json_execute(&mut self, args: &[&str]) -> Result<Value, ExifToolError> {
    let mut cmd_args = vec!["-json"];
    cmd_args.extend_from_slice(args);
    let output_bytes = self.execute_raw(&cmd_args)?;
    // Handle empty output gracefully - ExifTool might return empty output for
    // certain commands or errors that weren't caught via stderr.
    if output_bytes.is_empty() {
        // Or return Ok(Value::Null) or Ok(Value::Array(vec![])) ?
        return Err(ExifToolError::UnexpectedFormat {
            path: args
                .iter()
                .find(|a| !a.starts_with('-'))
                .unwrap_or(&"<unknown>")
                .to_string(),
            command_args: cmd_args.join(" "),
        });
    }
    // Note: serde_json::from_slice is not directly used here as execute_raw returns bytes.
    // Assuming a conversion to String or direct parsing from bytes happens implicitly or in a helper.
    // For the sake of documentation, let's assume a hypothetical direct parse or prior conversion:
    // serde_json::from_slice(&output_bytes).map_err(|e| ExifToolError::Json(e))
    // Since the provided code snippet doesn't show the actual JSON parsing from bytes,
    // this is a placeholder illustrating the intent.
    unimplemented!("JSON parsing logic is needed here.")
}
```

--------------------------------

### Execute ExifTool Command and Get Lines (Rust)

Source: https://docs.rs/exiftool/latest/exiftool/struct

Executes an ExifTool command with specified arguments and returns the output as a vector of strings. It handles potential `ExifToolError` during execution, such as IO failures, file not found errors, or unexpected process termination. Input is a slice of string slices representing command arguments, and output is a `Result` containing a vector of strings or an `ExifToolError`.

```Rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

let mut exiftool = ExifTool::new()?;
let path = Path::new("data/image.jpg");
// Get Date/Time Original tag in standard (-S) format
let output_lines = exiftool.execute_lines(&["-S", "-DateTimeOriginal", path.to_str().unwrap()])?;
for line in output_lines {
    println!("{}", line); // Example output: "DateTimeOriginal: 2023:10:27 10:00:00"
}
```

--------------------------------

### ExifTool Rust: Deserializing Metadata

Source: https://docs.rs/exiftool/latest/exiftool

Shows how to use the exiftool Rust library to read metadata and deserialize it directly into Rust structs. This example demonstrates reading specific tags into a custom `ImageMetadata` struct and also reading a single tag into a `String`. It highlights the flexibility of deserializing partial or full metadata based on predefined or dynamically created structs.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct ImageMetadata {
    #[serde(rename = "FileName")]
    file_name: String,
    #[serde(rename = "ImageWidth")]
    width: u32,
    #[serde(rename = "ImageHeight")]
    height: u32,
}

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let image_path = Path::new("path/to/your/image.jpg");

    // Read specific tags and deserialize into a struct
    let partial_meta: ImageMetadata = exiftool.read_tags(
        image_path,
        &["FileName", "ImageWidth", "ImageHeight"]
    )?;
    println!("Partial Metadata: {:?}", partial_meta);

    // Read all metadata (grouped) and deserialize
    // Note: Requires a struct matching ExifTool's -g/-G output structure
    // let full_meta: YourFullMetadataStruct = exiftool.read_metadata(image_path, &["-g1"])?;
    // println!("Full Metadata: {:?}", full_meta);

    // Read a single tag and deserialize
    let author: String = exiftool.read_tag(image_path, "Author")?;
    println!("Author: {}", author);

    Ok(())
}

```

--------------------------------

### Read All Metadata with Grouping in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Demonstrates extracting all metadata from a file and organizing it into structured groups based on tag families (e.g., EXIF, XMP). This utilizes the `-g1` ExifTool option for grouping and deserializes the output into a custom Rust struct using serde. The example shows how to access nested metadata fields.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct FullMetadata {
    #[serde(rename = "SourceFile")]
    source_file: String,
    #[serde(rename = "EXIF")]
    exif: Option<ExifGroup>,
    #[serde(rename = "XMP")]
    xmp: Option<XmpGroup>,
    #[serde(rename = "Composite")]
    composite: Option<CompositeGroup>,
}

#[derive(Deserialize, Debug)]
struct ExifGroup {
    #[serde(rename = "Make")]
    make: Option<String>,
    #[serde(rename = "DateTimeOriginal")]
    date_time_original: Option<String>,
}

#[derive(Deserialize, Debug)]
struct XmpGroup {
    #[serde(rename = "Creator")]
    creator: Option<String>,
    #[serde(rename = "Rights")]
    rights: Option<String>,
}

#[derive(Deserialize, Debug)]
struct CompositeGroup {
    #[serde(rename = "Aperture")]
    aperture: Option<String>,
    #[serde(rename = "ShutterSpeed")]
    shutter_speed: Option<String>,
}

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let path = Path::new("image.jpg");

    // -g1 groups tags by family (EXIF, XMP, IPTC, etc.)
    let metadata: FullMetadata = exiftool.read_metadata(path, &["-g1"])?;

    println!("File: {}", metadata.source_file);
    if let Some(exif) = metadata.exif {
        println!("Camera: {:?}, Captured: {:?}", exif.make, exif.date_time_original);
    }
    if let Some(xmp) = metadata.xmp {
        println!("Creator: {:?}, Rights: {:?}", xmp.creator, xmp.rights);
    }

    Ok(())
}
```

--------------------------------

### Read Multiple Tags into Struct in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Shows how to read multiple metadata tags from a file and deserialize them directly into a custom Rust struct using serde. This provides compile-time type checking for extracted metadata. The example defines a `CameraInfo` struct and populates it with specific tags.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use serde::Deserialize;

#[derive(Deserialize, Debug)]
struct CameraInfo {
    #[serde(rename = "Make")]
    make: Option<String>,
    #[serde(rename = "Model")]
    model: Option<String>,
    #[serde(rename = "FocalLength")]
    focal_length: Option<String>,
    #[serde(rename = "ISO")]
    iso: Option<u32>,
}

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let path = Path::new("photo.jpg");

    let camera: CameraInfo = exiftool.read_tags(
        path,
        &["Make", "Model", "FocalLength", "ISO"]
    )?;

    println!("Camera: {:?}", camera);
    if let Some(focal) = camera.focal_length {
        println!("Shot at: {}", focal);
    }

    Ok(())
}
```

--------------------------------

### Deserialize EXIF String List with Serde

Source: https://docs.rs/exiftool/latest/src/exiftool/structs/g2

Demonstrates deserializing a string list for EXIF data using Serde and a custom parser. Handles optional fields and provides example values.

```rust
    #[serde(
        deserialize_with = "crate::parse_fn::string_list::string_list",
        default
    )]
    pub directory_item_semantic: Option<Vec<String>>
```

--------------------------------

### Read Binary Thumbnail Image Tag

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Reads the 'ThumbnailImage' tag as binary data from a given image path. It asserts that the returned bytes are not empty and conform to JPEG start and end markers. Requires the 'exiftool' executable to be available.

```rust
fn test_read_tag_binary() -> Result<(), ExifToolError> {
        let mut et = ExifTool::new()?;
        let path = test_image_path();
        let thumb_bytes = et.read_tag_binary(path.as_path(), "ThumbnailImage")?;
        assert!(!thumb_bytes.is_empty());
        // Add basic JPEG check if needed (requires image crate)
        assert!(thumb_bytes.starts_with(b"\xFF\xD8")); // JPEG SOI marker
        assert!(thumb_bytes.ends_with(b"\xFF\xD9")); // JPEG EOI marker
        Ok(())
    }
```

--------------------------------

### Rust ExifTool: Basic Metadata Operations

Source: https://docs.rs/exiftool/latest/index

Demonstrates basic usage of the exiftool Rust library for reading and writing metadata tags. It shows how to initialize the ExifTool process, read specific tags as JSON, read all metadata, write a tag, and read binary data. The library keeps a long-running ExifTool process open for efficiency.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?; // Starts the background ExifTool process
    let image_path = Path::new("path/to/your/image.jpg");

    // Read a specific tag as a JSON Value
    let author_value = exiftool.json_tag(image_path, "Author")?;
    if let Some(author) = author_value.as_str() {
        println!("Author: {}", author);
    }

    // Read all metadata as a JSON Value (grouped by category)
    let metadata_json = exiftool.json(image_path, &["-g1"])?;
    println!("Metadata JSON: {}", metadata_json);

    // Write a tag
    exiftool.write_tag(image_path, "UserComment", "This is a test comment", &["-overwrite_original"])?;

    // Read binary data (e.g., thumbnail)
    let thumbnail_bytes = exiftool.read_tag_binary(image_path, "ThumbnailImage")?;
    println!("Read {} bytes for thumbnail", thumbnail_bytes.len());

    // Remember ExifTool process closes when `exiftool` variable goes out of scope (Drop).
    Ok(())
}

```

--------------------------------

### Read ExifTool JSON Tag in Rust

Source: https://docs.rs/exiftool/latest/exiftool/struct

Reads a specific tag from a file using ExifTool and returns its value as a JSON Value. This function is useful for getting raw tag data before specific deserialization. It handles cases where the tag might not be found, returning an ExifToolError::TagNotFound.

```rust
use exiftool::ExifTool;
use std::path::Path;
use serde_json::Value;

let mut et = ExifTool::new()?;
let path = Path::new("data/image.jpg");

let make_value: Value = et.json_tag(path, "Make")?;
assert!(make_value.is_string());
println!("Make JSON value: {}", make_value); // Output: "Huawei"

let width_value: Value = et.json_tag(path, "ImageWidth")?;
assert!(width_value.is_number());
println!("Width JSON value: {}", width_value); // Output: 2688

let missing_result = et.json_tag(path, "NonExistentTag");
assert!(matches!(missing_result, Err(ExifToolError::TagNotFound { .. })));
```

--------------------------------

### Initialize ExifTool Process in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Demonstrates how to create a persistent ExifTool process. It shows initialization using the system PATH or a custom executable location. The ExifTool process is automatically terminated when the variable goes out of scope.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn main() -> Result<(), ExifToolError> {
    // Use system PATH to find exiftool
    let mut exiftool = ExifTool::new()?;

    // Or specify custom executable path
    let custom_path = Path::new("/opt/local/bin/exiftool");
    let mut custom_exiftool = ExifTool::with_executable(custom_path)?;

    // Process automatically terminates when variable goes out of scope
    Ok(())
}
```

--------------------------------

### Batch Processing Robustness Check

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Initiates ExifTool and prepares for batch processing by listing files recursively from a specified directory. This test ensures the library can handle multiple files, though the actual processing logic is not shown in this snippet.

```rust
fn test_batch_processing_robustness() -> Result<(), ExifToolError> {
        let test_dir = Path::new("data/valid");
        let files = list_files_recursive(test_dir).expect("Failed to list test files");
        assert!(!files.is_empty(), "No test files found in data/valid");

        let mut exiftool = ExifTool::new()?;

```

--------------------------------

### Execute Lines - General Command Execution

Source: https://docs.rs/exiftool/latest/exiftool/struct

Executes a command with the exiftool binary and returns the output as a vector of strings, line by line. This is useful for commands where structured output like JSON is not required or desired.

```APIDOC
## POST /execute/lines

### Description
Executes a command with the exiftool binary and returns the output as a vector of strings, line by line. This is useful for commands where structured output like JSON is not required or desired.

### Method
POST

### Endpoint
/execute/lines

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **args** (array of strings) - Required - A slice of command-line arguments to pass to exiftool.

### Request Example
```json
{
  "args": ["-S", "-DateTimeOriginal", "data/image.jpg"]
}
```

### Response
#### Success Response (200)
- **output_lines** (array of strings) - A vector of strings, where each string is a line from the exiftool output.

#### Response Example
```json
{
  "output_lines": [
    "DateTimeOriginal: 2023:10:27 10:00:00"
  ]
}
```

### Errors
Returns an `ExifToolError` variant if the command fails, including:
  * `ExifToolError::Io`: If communication with the process fails.
  * `ExifToolError::FileNotFound`: If `exiftool` reports the file was not found.
  * `ExifToolError::ExifToolProcess`: If `exiftool` reports other errors on stderr.
  * `ExifToolError::Utf8`: If the output from `exiftool` is not valid UTF-8.
  * `ExifToolError::ProcessTerminated`: If the process exits unexpectedly.
```

--------------------------------

### Rust: Interact with ExifTool Process

Source: https://docs.rs/exiftool/latest/exiftool/struct

Demonstrates how to create and use an `ExifTool` instance to read metadata from a file. The `ExifTool` struct manages a persistent `exiftool` process in `-stay_open` mode for efficient command execution. Communication is done via stdin, stdout, and stderr, with automatic process termination upon dropping the struct.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;

fn main() -> Result<(), ExifToolError> {
    // Create an ExifTool instance (launches the process)
    let mut et = ExifTool::new()?;

    // Use methods to interact with exiftool...
    let path = Path::new("image.jpg");
    let width: u32 = et.read_tag(path, "ImageWidth")?;
    println!("Width: {}", width);

    // The process is automatically closed when `et` goes out of scope
    // or explicitly via `drop(et)`.

    Ok(())
}

```

--------------------------------

### Deserialize String or Vec<String> in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/parse_fn/string_list

This Rust function `string_list` deserializes a value that can be either a single string or a vector of strings. It's useful for handling flexible data formats where a field might contain one item or multiple items. The function leverages `serde` for deserialization and returns an `Option<Vec<String>>`.

```rust
use serde::{Deserialize, Deserializer};

#[derive(Deserialize)]
#[serde(untagged)]
enum StringOrVec {
    Vec(Vec<String>),
    String(String),
}

pub fn string_list<'de, D>(deserializer: D) -> Result<Option<Vec<String>>, D::Error>
where
    D: Deserializer<'de>,
{
    let helper: Option<StringOrVec> = Option::deserialize(deserializer)?;
    match helper {
        Some(StringOrVec::Vec(v)) => Ok(Some(v)),
        Some(StringOrVec::String(s)) => Ok(Some(vec![s])),
        None => Ok(None),
    }
}
```

--------------------------------

### Rust: Execute ExifTool Command Returning Lines

Source: https://docs.rs/exiftool/latest/exiftool/struct

Illustrates the `execute_lines` method, which executes an `exiftool` command and returns the standard output split into lines as a `Vec<String>`. This method is suitable for commands where line-based output is expected. It also monitors stderr for errors and logs warnings.

```rust
pub fn execute_lines( &mut self, args: &[&str], ) -> Result<Vec<String>, ExifToolError>

```

--------------------------------

### Structured Metadata with g2 Module in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Utilizes pre-defined structs from the g2 module in rs-exiftool for common metadata patterns organized by category groups. This allows for easy deserialization of EXIF data into structured Rust types like ExifData, VideoMetadata, CameraMetadata, and LocationMetadata. Input is a file path, and output is structured data. Dependencies include exiftool and serde crates.

```rust
use exiftool::{ExifTool, ExifToolError};
use exiftool::g2::{ExifData, VideoMetadata, CameraMetadata, LocationMetadata};
use std::path::Path;
use serde::Deserialize;

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;

    // Use pre-built ExifData struct with grouped metadata
    let photo_path = Path::new("photo.jpg");
    let exif_data: ExifData = exiftool.read_metadata(photo_path, &["-g1"])?;

    // Access grouped metadata
    if let Some(camera) = exif_data.camera {
        println!("Camera: {:?} {:?}", camera.make, camera.model);
    }
    if let Some(location) = exif_data.location {
        println!("GPS: {:?}, {:?}", location.gps_latitude, location.gps_longitude);
    }

    // Video metadata
    let video_path = Path::new("video.mp4");
    let video_meta: VideoMetadata = exiftool.read_metadata(video_path, &["-g2"])?;
    println!("Video: {}x{}, duration: {:?}, fps: 0{:?}",
        video_meta.image_width.unwrap_or(0),
        video_meta.image_height.unwrap_or(0),
        video_meta.duration,
        video_meta.video_frame_rate
    );

    Ok(())
}

```

--------------------------------

### Test ExifTool File Not Found Error Handling in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Tests the ExifTool's ability to return a FileNotFound error when a non-existent path is provided for both standard execution and raw execution. It ensures the correct error variant and path are returned.

```rust
let non_existent_path = PathBuf::from("non_existent_file.jpg");
        let raw_result = et.execute_raw(&[non_existent_path.to_str().unwrap()]);
        assert_matches!(
            raw_result,
            Err(ExifToolError::FileNotFound { path, .. }) if path == non_existent_path
        );
        Ok(())
    }

    #[test]
    fn test_read_metadata_json_single() -> Result<(), ExifToolError> {
        let mut et = ExifTool::new()?;
        let path = test_image_path();
        let meta = et.json(path.as_path(), &["-Make", "-Model"])?;

        assert!(meta.is_object());
        assert_eq!(
            meta.get("SourceFile").and_then(|v| v.as_str()),
            Some(path.to_str().unwrap())
        );
        assert_eq!(meta.get("Make").and_then(|v| v.as_str()), Some("Huawei"));
        assert_eq!(meta.get("Model").and_then(|v| v.as_str()), Some("Nexus 6P"));
        Ok(())
    }
```

--------------------------------

### Rust VideoMetadata Clone Trait Implementation

Source: https://docs.rs/exiftool/latest/exiftool/g2/struct

Demonstrates the implementation of the Clone trait for the VideoMetadata struct in Rust. This allows for creating deep copies of VideoMetadata instances, ensuring that owned data is duplicated rather than shared. The `clone` and `clone_from` methods are provided.

```rust
impl Clone for VideoMetadata
fn clone(&self) -> VideoMetadata
fn clone_from(&mut self, source: &Self)

```

--------------------------------

### Write Binary Metadata Tags with rs-exiftool in Rust

Source: https://context7.com/context7/rs_exiftool/llms.txt

Writes binary data, such as thumbnails or preview images, into file metadata using the rs-exiftool crate. It reads binary data from a file and embeds it into the target file's metadata. The function also includes verification by reading the embedded data back and extracting it to a new file.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use std::fs;

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let photo_path = Path::new("photo.jpg");
    let thumb_path = Path::new("custom_thumbnail.jpg");

    // Read thumbnail bytes from file
    let thumbnail_data = fs::read(thumb_path).map_err(ExifToolError::Io)?;

    // Write thumbnail to photo metadata
    exiftool.write_tag_binary(
        photo_path,
        "ThumbnailImage",
        &thumbnail_data,
        &["-overwrite_original"]
    )?;

    // Verify by reading back
    let stored_thumb = exiftool.read_tag_binary(photo_path, "ThumbnailImage")?;
    assert_eq!(thumbnail_data.len(), stored_thumb.len());
    println!("Successfully embedded {}-byte thumbnail", stored_thumb.len());

    // Extract and save thumbnail
    fs::write("extracted_thumb.jpg", &stored_thumb).map_err(ExifToolError::Io)?;

    Ok(())
}

```

--------------------------------

### Deserialize MPFVersion with Alias and String Parser

Source: https://docs.rs/exiftool/latest/src/exiftool/structs/g2

Demonstrates deserializing the MPF (Multi-Picture Format) version using Serde, with an alias 'MPFVersion' and a custom string parser.

```rust
    #[serde(
        alias = "MPFVersion",
        deserialize_with = "crate::parse_fn::string::string",
        default
    )]
    pub mpf_version: Option<String>
```

--------------------------------

### Rust VideoMetadata Deserialize Trait Implementation

Source: https://docs.rs/exiftool/latest/exiftool/g2/struct

Illustrates the implementation of the Deserialize trait for the VideoMetadata struct using Serde in Rust. This allows VideoMetadata instances to be created from various data formats like JSON or other serialized representations. The `deserialize` method is the core of this implementation.

```rust
impl<'de> Deserialize<'de> for VideoMetadata
fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>
where __D: Deserializer<'de>

```

--------------------------------

### Read Multiple Image Metadata Tags into a Struct with rs_exiftool

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Demonstrates reading multiple metadata tags (Make, Model, ImageWidth, Software) from an image and directly deserializing them into a Rust struct (`CameraInfo`). This simplifies processing when several related metadata fields are needed.

```rust
#[derive(Deserialize, Debug, PartialEq)]
        #[serde(rename_all = "PascalCase")] // Match ExifTool's typical tag names
        struct CameraInfo {
            make: String,
            model: String,
            image_width: u32,
            software: Option<String>, // Handle optional tags
        }

        let mut et = ExifTool::new()?;
        let path = test_image_path();
        let info: CameraInfo =
            et.read_tags(path.as_path(), &["Make", "Model", "ImageWidth", "Software"])?;

        assert_eq!(info.make, "Huawei");
        assert_eq!(info.model, "Nexus 6P");
        assert!(info.image_width > 0);
        assert!(info.software.is_some());
        Ok(())
    }
```

--------------------------------

### Batch Process Files with ExifTool and Extract SourceFile (Rust)

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

This Rust code snippet processes a collection of files using exiftool's `json_batch` function to extract the 'SourceFile' metadata. It then iterates through the results, asserts the number of results matches the input files, and verifies that the 'SourceFile' is present and correctly matches the original file's name.

```rust
        // Use AsRef<Path> directly
        let results = exiftool.json_batch(files.iter(), &["-SourceFile"])?;

        assert_eq!(results.len(), files.len());

        for (i, result_val) in results.iter().enumerate() {
            let source_file = result_val
                .get("SourceFile")
                .and_then(Value::as_str)
                .map(PathBuf::from);
            assert!(
                source_file.is_some(),
                "SourceFile missing in result for index {i}"
            );
            // Note: Comparing paths directly can be tricky due to CWD differences.
            // Compare basenames or canonicalize if needed, but checking existence is good.
            assert!(
                source_file
                    .unwrap()
                    .ends_with(files[i].file_name().unwrap()),
                "Mismatch for file {}",
                files[i].display()
            );
        }
        Ok(())
    }
}
```

--------------------------------

### Read Specific Metadata Tag as JSON with rs_exiftool

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Demonstrates reading a single metadata tag (Make) from an image file and asserting its JSON value. This is useful for quickly retrieving a specific piece of metadata.

```rust
let mut et = ExifTool::new()?;
        let path = test_image_path();
        let make = et.json_tag(path.as_path(), "Make")?;
        assert_eq!(make, json!("Huawei"));
        Ok(())
    }
```

--------------------------------

### Execute Raw ExifTool Command and Capture Output in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

This Rust function, `execute_raw`, handles the low-level execution of exiftool commands. It sends arguments to the exiftool process's stdin, reads the response from stdout until a ready signal, and captures any errors from stderr. This function is primarily for internal use and is not recommended for typical application needs.

```rust
pub fn execute_raw(&mut self, args: &[&str]) -> Result<Vec<u8>, ExifToolError> {
    // 1. Clear any stale errors from previous commands
    while self.stderr_receiver.try_recv().is_ok() {}

    // 2. Send command arguments line-by-line
    for arg in args {
        writeln!(self.stdin, "{arg}")?;
    }
    // 3. Send the execute signal
    writeln!(self.stdin, "-execute")?;
    self.stdin.flush()?;

    // 4. Read the response from stdout
    let stdout_bytes = self.read_response_until_ready()?;

    // 5. Check for errors on stderr
    let stderr_lines = self.drain_stderr()?;

    // 6. Process results and errors
    if !stderr_lines.is_empty() {
        // Combine args for error reporting
        let command_args = args.join(" ");
        let combined_stderr = stderr_lines.join("\n");

        // Check for specific common errors first
        for err_line in &stderr_lines {
            if let Some(filename) = err_line.strip_prefix("Error: File not found - ") {
                return Err(ExifToolError::FileNotFound {
                    path: PathBuf::from(filename.trim()),
                    command_args,
                });
            } else if err_line.contains("Error:") {
                return Err(ExifToolError::ExifToolProcess {
                    message: err_line.to_string(),
                    std_err: combined_stderr,
                    command_args,
                });
            } else if err_line.contains("Warning:") {
            // ... (rest of the error handling)
```

--------------------------------

### Read File Metadata with Grouping (Rust)

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Reads metadata from a file and deserializes it into a custom struct, with tags grouped by category (e.g., EXIF, XMP). Requires the `serde` crate for deserialization and `serde_path_to_error` for better error reporting. Handles potential deserialization errors by providing context via JSON path.

```rust
use exiftool::{ExifTool, ExifToolError};
use std::path::Path;
use serde::Deserialize;

// Define a struct matching exiftool's -g1 (group 1) JSON output structure
#[derive(Deserialize, Debug)]
struct ExifData {
    #[serde(rename = "SourceFile")]
    source_file: String,
    #[serde(rename = "EXIF")]
    exif: Option<ExifGroup>,
    #[serde(rename = "XMP")]
    xmp: Option<XmpGroup>,
    // Add other groups as needed (Composite, MakerNotes, etc.)
}

#[derive(Deserialize, Debug)]
struct ExifGroup {
    #[serde(rename = "Make")]
    make: Option<String>,
    #[serde(rename = "Model")]
    model: Option<String>,
    // ... other EXIF tags
}

#[derive(Deserialize, Debug)]
struct XmpGroup {
    #[serde(rename = "Creator")]
    creator: Option<String>, // Example XMP tag
    // ... other XMP tags
}

fn main() -> Result<(), ExifToolError> {
    let mut exiftool = ExifTool::new()?;
    let path = Path::new("data/image.jpg");

    // Read metadata grouped by category (-g1)
    let metadata: ExifData = exiftool.read_metadata(path, &["-g1"])?;

    println!("Source File: {}", metadata.source_file);
    if let Some(exif) = metadata.exif {
        println!("Make: {:?}", exif.make);
    }
    Ok(())
}
```

--------------------------------

### Read Metadata for Multiple Files (Rust)

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

Efficiently reads metadata for multiple files by running `exiftool -json` with batch file paths. It expects a JSON array output from exiftool, where each element corresponds to a file. Handles empty file lists and potential parsing errors.

```rust
pub fn json_batch<I, P>(
    &mut self,
    file_paths: I,
    extra_args: &[&str],
) -> Result<Vec<Value>, ExifToolError>
where
    I: IntoIterator<Item = P>,
    P: AsRef<Path>,
{
    let path_strs: Vec<String> = file_paths
        .into_iter()
        .map(|p| p.as_ref().to_string_lossy().into_owned())
        .collect();

    if path_strs.is_empty() {
        return Err(ExifToolError::UnexpectedFormat {
            path: "".to_string(),
            command_args: extra_args.join(","),
        });
    }

    let mut args = extra_args.to_vec();
    let path_refs: Vec<&str> = path_strs.iter().map(String::as_str).collect();
    args.extend_from_slice(&path_refs);

    let result_value = self.json_execute(&args)?;

    match result_value {
        Value::Array(array) => Ok(array),
        _ => Err(ExifToolError::UnexpectedFormat {
            path: path_strs.join(", "),
            command_args: format!("-json {}", args.join(" ")),
        }),
    }
}
```

--------------------------------

### Write Binary Tag with ExifTool in Rust

Source: https://docs.rs/exiftool/latest/src/exiftool/exiftool

This function writes binary data to a specified tag in an image file using ExifTool. It creates a temporary file to hold the binary data, constructs the appropriate ExifTool command, and executes it. It requires a file path, tag name, the binary data as a byte slice, and optional extra arguments for ExifTool.

```Rust
pub fn write_tag_binary<D: AsRef<[u8]>>(
        &mut self,
        file_path: &Path,
        tag: &str,
        data: D,
        extra_args: &[&str],
    ) -> Result<(), ExifToolError> {
        // Create a temporary file to hold the binary data
        let mut temp_file = NamedTempFile::new()?;
        temp_file.write_all(data.as_ref())?;
        temp_file.flush()?;

        let temp_path_str = temp_file.path().to_string_lossy();

        // Construct the field argument with the '<=' operator.
        let tag_arg = format!("-{tag}<={temp_path_str}");

        let file_path_str = file_path.to_string_lossy();
        let mut args = vec![tag_arg.as_str()];
        args.extend_from_slice(extra_args);
        args.push(file_path_str.as_ref());

        // Execute and ignore output. temp_file is dropped (and deleted) after this scope.
        let _ = self.execute_raw(&args)?;
        Ok(())
    }
```

--------------------------------

### Rust Generic Implementations for VideoMetadata

Source: https://docs.rs/exiftool/latest/exiftool/g2/struct

Details the auto and blanket trait implementations for the VideoMetadata struct in Rust. These include implementations for thread safety (Send, Sync, Unpin, Freeze, RefUnwindSafe, UnwindSafe) and generic functionalities like Any, Borrow, BorrowMut, CloneToUninit, and From/Into.

```rust
impl Freeze for VideoMetadata
impl RefUnwindSafe for VideoMetadata
impl Send for VideoMetadata
impl Sync for VideoMetadata
impl Unpin for VideoMetadata
impl UnwindSafe for VideoMetadata

impl<T> Any for T where T: 'static + ?Sized
impl<T> Borrow<T> for T where T: ?Sized
impl<T> BorrowMut<T> for T where T: ?Sized
impl<T> CloneToUninit for T where T: Clone
impl<T> From<T> for T
impl<T, U> Into<U> for T where U: From<T>

```
Tokens:
Raw