### iMessage Exporter CLI Usage Examples (Bash)

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This section provides various command-line examples for the `imessage-exporter` binary. It covers installation, exporting to HTML or TXT formats, handling attachments, filtering by date or contact, exporting from iOS backups (including encrypted ones), running diagnostics, and customizing display names.

```bash
# Install via cargo
car go install imessage-exporter

# Export to HTML with web-compatible attachments (converts HEIC, CAF, MOV)
imessage-exporter -f html -c full

# Export to TXT with original attachment formats
imessage-exporter -f txt -o output -c clone

# Export from iOS backup
imessage-exporter -f txt -p ~/iphone_backup -a iOS -o backup_export

# Export from custom database path without copying attachments
imessage-exporter -f html -c disabled -p /Volumes/external/chat.db -o /Volumes/external/export

# Export with custom attachment root (attachments stored separately)
imessage-exporter -f html -c clone -p /Volumes/external/chat.db \
  -r /Volumes/external/Attachments -o /Volumes/external/export

# Filter by date range
imessage-exporter -f txt -o ~/export-2020 -s 2020-01-01 -e 2021-01-01

# Filter by specific contact
imessage-exporter -f html -c clone -t "5558675309"
imessage-exporter -f txt -t "Steve Jobs"

# Filter by multiple contacts
imessage-exporter -f html -t "5558675309,steve@apple.com"

# Filter by country/area code pattern
imessage-exporter -f html -t "+1555"

# Export from encrypted iOS backup
imessage-exporter -f html -p ~/encrypted_backup -a iOS -x "backup_password"

# Run diagnostics only
imessage-exporter -d

# Use custom display name instead of "Me"
imessage-exporter -f html -m "John"

# Use caller ID for sender identification
imessage-exporter -f html -i
```

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

### Export iMessages to TXT with Cloned Attachments

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages to TXT format, copying attachments in their original formats. Saves the output to a folder named 'output' in the current directory.

```zsh
imessage-exporter -f txt -o output -c clone
```

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

### Rust command for wkhtmltopdf with local file access

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Demonstrates how to use Rust's Command module to execute wkhtmltopdf with the '--enable-local-file-access' flag, attempting to render local images for PDF conversion.

```rust
let mut process = Command::new("wkhtmltopdf")
.args(&vec![
    "--enable-local-file-access".to_string(),
    html_path,
    pdf_path.to_string_lossy().to_string(),
])
.spawn()
.unwrap();
```

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

### Export iMessages from iPhone Backup to TXT

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from a specified iPhone backup location to TXT format. Attachments are copied in their original formats, and the output is saved to 'backup_export'.

```zsh
imessage-exporter -f txt -p ~/iphone_backup_latest -a iOS -o backup_export
```

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

### Export iMessages to HTML without Attachments

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages to HTML format from a specific database file without copying attachments. Output is saved to a specified directory.

```zsh
imessage-exporter -f html -c disabled -p /Volumes/external/chat.db -o /Volumes/external/export
```

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

### Export iMessages to HTML with Specific Attachments Folder

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages to HTML format from a specific database file, copying attachments from a designated folder. Output is saved to a specified directory.

```zsh
imessage-exporter -f html -c clone -p /Volumes/external/chat.db -r /Volumes/external/Attachments -o /Volumes/external/export
```

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

### Build Tapback Reaction Cache in Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This Rust code builds a cache of tapback reactions from the iMessage database, organized by target message GUID and body part index. It utilizes the `imessage_database` crate and the `Cacheable` trait. The output is a HashMap suitable for rendering reactions.

```rust
use imessage_database::
    tables::
        messages::Message,
        table::{get_connection, Cacheable},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Cache all tapbacks: HashMap<String, HashMap<usize, Vec<Message>>>
// Structure: message_guid -> body_part_index -> [tapback_messages]
let tapbacks = Message::cache(&db).unwrap();

// Look up tapbacks for a specific message
let message_guid = "ABCD1234-5678-90EF-GHIJ-KLMNOPQRSTUV";
if let Some(parts) = tapbacks.get(message_guid) {
    for (part_idx, reactions) in parts {
        println!("Reactions on part {}:", part_idx);
        for reaction in reactions {
            println!("  {:?} from handle {}",
                reaction.variant(),
                reaction.handle_id.unwrap_or(0)
            );
        }
    }
}
```

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

### Export iMessages from Specific Participant Name to TXT

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from a specific participant name to TXT format without attachments. Output is saved to the user's home directory.

```zsh
imessage-exporter -f txt -t "Steve Jobs"
```

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

### Export iMessages from Multiple Participants to HTML

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from multiple specified participants (phone numbers or email addresses) to HTML format without attachments. Output is saved to the user's home directory.

```zsh
imessage-exporter -f html -t "5558675309,steve@apple.com"
```

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

### Export iMessages to HTML with Full Attachments

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages to HTML format, copying attachments in web-compatible formats. Uses the default iMessage database location and saves to the user's home directory.

```zsh
imessage-exporter -f html -c full
```

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

### Export iMessages from Email Addresses to HTML

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from participants using email addresses (but not phone numbers) to HTML format without attachments. Output is saved to the user's home directory.

```zsh
imessage-exporter -f html -t "@"
```

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

### Export iMessages from Specific Participant to HTML

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from a specific phone number to HTML format, copying attachments in their original formats. Output is saved to the user's home directory.

```zsh
imessage-exporter -f html -c clone -t "5558675309"
```

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

### Export iMessages within a Date Range to TXT

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages within a specified date range (2020-01-01 to 2020-12-31) to TXT format from the default macOS iMessage database. Output is saved to '~/export-2020'.

```zsh
imessage-exporter -f txt -o ~/export-2020 -s 2020-01-01 -e 2021-01-01 -a macOS
```

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

### Export iMessages from Participants Matching Country Code to HTML

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-exporter/README.md

Exports iMessages from participants matching a specific country and area code (e.g., +1555) to HTML format without attachments. Output is saved to the user's home directory.

```zsh
imessage-exporter -f html -t "+1555"
```

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

### Work with Attachments - Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Retrieves and manages attachments associated with messages. This includes getting attachment metadata like filename, MIME type, and file size, as well as resolving the actual file path on macOS and iOS. It can also read attachment content as bytes. Requires the 'imessage_database' crate.

```rust
use imessage_database::{
    tables::{
        attachment::Attachment,
        messages::Message,
        table::{get_connection, Table},
    },
    util::{dirs::default_db_path, platform::Platform},
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

Message::stream(&db, |message_result| {
    if let Ok(message) = message_result {
        if message.has_attachments() {
            // Get all attachments for this message
            let attachments = Attachment::from_message(&db, &message).unwrap();

            for attachment in attachments {
                // Get attachment metadata
                println!("Filename: {:?}", attachment.filename());
                println!("MIME type: {:?}", attachment.mime_type());
                println!("File size: {}", attachment.file_size());
                println!("Is sticker: {}", attachment.is_sticker);

                // Resolve the actual file path
                if let Some(path) = attachment.resolved_attachment_path(
                    &Platform::macOS,
                    &db_path,
                    None  // Optional custom attachment root
                ) {
                    println!("Full path: {}", path);
                }

                // Read attachment as bytes
                if let Ok(Some(bytes)) = attachment.as_bytes(
                    &Platform::macOS,
                    &db_path,
                    None
                ) {
                    println!("Attachment size: {} bytes", bytes.len());
                }
            }
        }
    }
    Ok::<(), imessage_database::error::table::TableError>(())
}).unwrap();
```

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

### Iterate iMessage Messages - Rust

Source: https://github.com/reagentx/imessage-exporter/blob/develop/imessage-database/README.md

Demonstrates how to establish a read-only connection to an iMessage database and stream messages. It includes deserializing message bodies and printing debug information for each message. Requires the 'imessage-database' crate.

```rust
use imessage_database::
    error::table::TableError,
    tables::
        messages::Message,
        table::{get_connection, Table},
    util::dirs::default_db_path;

fn iter_messages() -> Result<(), TableError> {
    // Create a read-only connection to an iMessage database
    let db = get_connection(&default_db_path()).unwrap();

    // Iterate over a stream of messages
    Message::stream(&db, |message_result| {
        match message_result {
            Ok(mut message) => {
                // Deserialize the message body
                message.generate_text(&db);

                // Emit debug info for each message
                println!("Message: {:#?}", message)
            },
            Err(e) => eprintln!("Error: {:?}", e),
        };

        // You can substitute your own closure error type
        Ok::<(), TableError>(())
    })?;

    Ok(())
}
```

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

### Run Database Diagnostics in Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This Rust code snippet executes diagnostic analyses on iMessage database tables to identify potential issues such as missing attachments, orphaned messages, or duplicate handles. It uses the `Diagnostic` trait from the `imessage_database` crate and requires platform information for attachment diagnostics.

```rust
use imessage_database::
    tables::
        attachment::Attachment,
        handle::Handle,
        messages::Message,
        table::{get_connection, Diagnostic},
    },
    util::{dirs::default_db_path, platform::Platform},
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Run message diagnostics
// Reports: total messages, messages without chats, messages in multiple chats
Message::run_diagnostic(&db).unwrap();

// Run handle diagnostics
// Reports: total handles, duplicated handles, handles with multiple IDs
Handle::run_diagnostic(&db).unwrap();

// Run attachment diagnostics (requires platform info)
// Reports: total attachments, missing files, data size on disk vs referenced
Attachment::run_diagnostic(&db, &db_path, &Platform::macOS).unwrap();
```

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

### Connect to iMessage Database (Rust)

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Establishes a read-only SQLite connection to an iMessage database. Supports macOS chat.db files and iOS backup directories. This is the entry point for library operations.

```rust
use imessage_database::{
    tables::table::get_connection,
    util::dirs::default_db_path,
};

// Connect to the default macOS iMessage database location
// Default path: ~/Library/Messages/chat.db
let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Connect to a custom database path (e.g., iOS backup or external drive)
use std::path::PathBuf;
let custom_path = PathBuf::from("/Volumes/Backup/chat.db");
let db = get_connection(&custom_path).unwrap();

// Connect to an iOS backup directory
let ios_backup_path = PathBuf::from("~/iphone_backup/3d/3d0d7e5fb2ce288813306e4d4636395e047a3d28");
let db = get_connection(&ios_backup_path).unwrap();
```

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

### Cache Contact Handles and Deduplicate - Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Builds an in-memory cache of contact handles, mapping handle IDs to their identifiers (phone numbers, emails). It also supports deduplicating handles that represent the same contact, returning a map of original IDs to deduplicated IDs. Requires the 'imessage_database' crate.

```rust
use imessage_database::{
    tables::{
        handle::Handle,
        table::{get_connection, Cacheable, Deduplicate},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Cache all handles: HashMap<i32, String> (handle_id -> identifier)
let handles = Handle::cache(&db).unwrap();

// Look up a contact by their handle ID
if let Some(contact_id) = handles.get(&5) {
    println!("Handle 5 is: {}", contact_id);  // e.g., "+15551234567" or "user@example.com"
}

// Deduplicate handles that represent the same person
// Returns HashMap<i32, i32> mapping original IDs to deduplicated IDs
let deduped = Handle::dedupe(&handles);

// Check if two handles point to the same contact
let handle_a = deduped.get(&1).unwrap();
let handle_b = deduped.get(&2).unwrap();
if handle_a == handle_b {
    println!("Handles 1 and 2 belong to the same contact");
}
```

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

### Generate Handle Metadata Map

Source: https://github.com/reagentx/imessage-exporter/blob/develop/docs/tables/duplicates.md

This code snippet demonstrates how to generate a map of Handle IDs to a combined string of their associated metadata (e.g., phone numbers, email addresses) based on the 'Person Centric ID'. This is a crucial step in solving the duplicate handle problem.

```python
def generate_handle_metadata_map(handles_table):
    """Generates a map of Handle ID to combined metadata string.

    Args:
        handles_table: A list of dictionaries representing the handles table.

    Returns:
        A dictionary mapping Handle ID to a string of combined metadata.
    """
    person_centric_to_handles = {}
    for handle in handles_table:
        person_id = handle['Person Centric ID']
        if person_id not in person_centric_to_handles:
            person_centric_to_handles[person_id] = []
        person_centric_to_handles[person_id].append(handle)

    handle_id_to_metadata = {}
    for handle in handles_table:
        person_id = handle['Person Centric ID']
        metadata_list = []
        for h in person_centric_to_handles[person_id]:
            metadata_list.append(h['Contact'])
        handle_id_to_metadata[handle['Handle ID']] = ", ".join(sorted(list(set(metadata_list))))

    return handle_id_to_metadata

# Example Usage:
handles_data = [
    {'Handle ID': 1, 'Contact': 'Y', 'Person Centric ID': 'A'},
    {'Handle ID': 2, 'Contact': 'X', 'Person Centric ID': 'A'},
    {'Handle ID': 3, 'Contact': 'Z', 'Person Centric ID': 'B'}
]

metadata_map = generate_handle_metadata_map(handles_data)
print(metadata_map)
# Expected Output: {1: 'X, Y', 2: 'X, Y', 3: 'Z'}
```

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

### Determine iMessage Variants and Types

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This snippet demonstrates how to determine the type or variant of an iMessage, including standard text, tapbacks, app messages, edits, and more. It utilizes the `imessage_database` crate to access message data and pattern match against various `Variant` enums. Dependencies include `imessage_database` for message structures and database access.

```rust
use imessage_database::
    message_types::variants::{Variant, Tapback, TapbackAction, CustomBalloon},
    tables::
        messages::Message,
        table::{get_connection, Table},
    util::dirs::default_db_path;

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

Message::stream(&db, |message_result| {
    if let Ok(message) = message_result {
        // Get the message variant
        match message.variant() {
            Variant::Normal => {
                println!("Standard text message");
            },
            Variant::Edited => {
                println!("Message was edited");
                if message.is_fully_unsent() {
                    println!("  All parts were unsent");
                }
            },
            Variant::Tapback(index, action, tapback) => {
                let action_str = match action {
                    TapbackAction::Added => "added",
                    TapbackAction::Removed => "removed",
                };
                println!("Tapback {} on part {}: {:?}", action_str, index, tapback);

                match tapback {
                    Tapback::Loved => println!("  Heart reaction"),
                    Tapback::Liked => println!("  Thumbs up"),
                    Tapback::Disliked => println!("  Thumbs down"),
                    Tapback::Laughed => println!("  Ha ha"),
                    Tapback::Emphasized => println!("  Exclamation"),
                    Tapback::Questioned => println!("  Question mark"),
                    Tapback::Emoji(e) => println!("  Custom emoji: {:?}", e),
                    Tapback::Sticker => println!("  Sticker tapback"),
                }
            },
            Variant::App(balloon) => {
                match balloon {
                    CustomBalloon::URL => println!("URL preview message"),
                    CustomBalloon::Handwriting => println!("Handwritten message"),
                    CustomBalloon::DigitalTouch => println!("Digital Touch message"),
                    CustomBalloon::ApplePay => println!("Apple Pay transaction"),
                    CustomBalloon::Fitness => println!("Fitness activity"),
                    CustomBalloon::CheckIn => println!("Check In message"),
                    CustomBalloon::FindMy => println!("Find My location"),
                    CustomBalloon::Polls => println!("Poll message"),
                    CustomBalloon::Application(bundle_id) => {
                        println!("App message from: {}", bundle_id);
                    },
                    _ => println!("Other app message"),
                }
            },
            Variant::SharePlay => println!("SharePlay/FaceTime message"),
            Variant::Vote => println!("Poll vote"),
            Variant::PollUpdate => println!("Poll update"),
            Variant::Unknown(code) => println!("Unknown message type: {}", code),
        }
    }
    Ok::<(), imessage_database::error::table::TableError>(())
}).unwrap();

```

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

### Query iMessage Messages with Filters (Rust)

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Creates filtered message queries using date ranges and chat/handle ID filters. Supports setting start/end dates and selecting specific chat IDs for precise data retrieval.

```rust
use std::collections::BTreeSet;
use imessage_database::{
    tables::{
        messages::Message,
        table::{get_connection, Table},
    },
    util::{
        dirs::default_db_path,
        query_context::QueryContext,
    },
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Create a query context with date filters
let mut context = QueryContext::default();
context.set_start("2023-01-01").unwrap();  // Messages on or after this date
context.set_end("2024-01-01").unwrap();    // Messages before this date

// Filter by specific chat IDs
context.set_selected_chat_ids(BTreeSet::from([1, 2, 3]));

// Get count of filtered messages
let count = Message::get_count(&db, &context).unwrap();
println!("Found {} messages in date range", count);

// Stream filtered messages
let mut statement = Message::stream_rows(&db, &context).unwrap();
let messages = statement.query_map([], |row| Ok(Message::from_row(row))).unwrap();

for msg_result in messages {
    if let Ok(Ok(message)) = msg_result {
        println!("Message from {}: {:?}", message.date, message.text);
    }
}
```

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

### Retrieve Threaded Replies to Messages in Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This Rust code snippet demonstrates how to retrieve threaded replies to messages from the iMessage database. It iterates through messages, checks for replies, and organizes them by the message body part they reply to. Dependencies include the `imessage_database` crate.

```rust
use imessage_database::
    tables::
        messages::Message,
        table::{get_connection, Table},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

Message::stream(&db, |message_result| {
    if let Ok(mut message) = message_result {
        message.generate_text(&db);

        // Check if this message starts a thread
        if message.has_replies() {
            println!("Message '{}' has {} replies",
                message.text.as_deref().unwrap_or(""),
                message.num_replies
            );

            // Get all replies indexed by body part
            let replies = message.get_replies(&db).unwrap();

            for (part_index, reply_messages) in &replies {
                println!("  Replies to part {}:", part_index);
                for reply in reply_messages {
                    println!("    - {:?}", reply.text);
                }
            }
        }

        // Check if this message is a reply
        if message.is_reply() {
            println!("This message replies to: {:?}", message.thread_originator_guid);
        }
    }
    Ok::<(), imessage_database::error::table::TableError>(())
}).unwrap();
```

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

### Stream iMessage Messages (Rust)

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Iterates over all messages in the database using a zero-allocation streaming API for efficient processing. Includes deserialization of message bodies and access to message properties.

```rust
use imessage_database::{
    error::table::TableError,
    tables::{
        messages::Message,
        table::{get_connection, Table},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Stream all messages with a callback
Message::stream(&db, |message_result| {
    match message_result {
        Ok(mut message) => {
            // Deserialize the message body (parses typedstream data)
            message.generate_text(&db);

            // Access message properties
            println!("GUID: {}", message.guid);
            println!("Text: {:?}", message.text);
            println!("From me: {}", message.is_from_me);
            println!("Has attachments: {}", message.has_attachments());
            println!("Is reply: {}", message.is_reply());
            println!("Is tapback: {}", message.is_tapback());
        },
        Err(e) => eprintln!("Error reading message: {:?}", e),
    }
    Ok::<(), TableError>(())
}).unwrap();
```

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

### Parse and Format iMessage Timestamps

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This code snippet illustrates how to work with iMessage timestamps, which are stored as nanosecond-precision values with an epoch of 2001-01-01. It uses the `imessage_database` crate to retrieve and format dates for sent, read, delivered, and edited messages, as well as calculate the time until a message is read. Key functions include `get_offset`, `format`, and `readable_diff`.

```rust
use imessage_database::
    tables::
        messages::Message,
        table::{get_connection, Table},
    util::
        dates::{format, get_offset, readable_diff},
        dirs::default_db_path;

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Get the timestamp offset for iMessage databases
let offset = get_offset();

Message::stream(&db, |message_result| {
    if let Ok(message) = message_result {
        // Get formatted date strings
        if let Ok(date) = message.date(&offset) {
            println!("Sent: {}", format(&Ok(date)));
        }

        if let Ok(date_read) = message.date_read(&offset) {
            println!("Read: {}", format(&Ok(date_read)));
        }

        if let Ok(date_delivered) = message.date_delivered(&offset) {
            println!("Delivered: {}", format(&Ok(date_delivered)));
        }

        // Get human-readable time until read
        if let Some(time_until_read) = message.time_until_read(&offset) {
            println!("Time until read: {}", time_until_read);
            // Output like: "2 days, 5 hours, 22 minutes, 34 seconds"
        }

        // Check if message was edited and get edit time
        if message.is_edited() {
            if let Ok(edit_date) = message.date_edited(&offset) {
                println!("Last edited: {}", format(&Ok(edit_date)));
            }
        }
    }
    Ok::<(), imessage_database::error::table::TableError>(())
}).unwrap();

```

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

### Cache Chats - Rust

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

Caches all chatrooms from the iMessage database, mapping chat IDs to Chat structs. This allows for easy access to conversation metadata such as the chat name and service type. Requires the 'imessage_database' crate.

```rust
use imessage_database::{
    tables::{
        chat::Chat,
        table::{get_connection, Cacheable},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

// Cache all chats: HashMap<i32, Chat>
let chats = Chat::cache(&db).unwrap();

// Access chat information
for (chat_id, chat) in &chats {
    println!("Chat {}: {} (service: {:?})",
        chat_id,
        chat.name(),           // Display name or chat_identifier
        chat.service_name      // "iMessage", "SMS", etc.
    );

    // Get optional custom display name
    if let Some(name) = chat.display_name() {
        println!("  Custom name: {}", name);
    }
}
```

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

### Detect iMessage Expressive Effects (Rust)

Source: https://context7.com/reagentx/imessage-exporter/llms.txt

This Rust code snippet demonstrates how to detect and process various expressive message effects, including bubble effects (Slam, Loud, Invisible Ink) and screen effects (Confetti, Balloons, Fireworks). It utilizes the `imessage-database` crate to stream messages and identify expressive types.

```rust
use imessage_database::{
    message_types::expressives::{Expressive, BubbleEffect, ScreenEffect},
    tables::{
        messages::Message,
        table::{get_connection, Table},
    },
    util::dirs::default_db_path,
};

let db_path = default_db_path();
let db = get_connection(&db_path).unwrap();

Message::stream(&db, |message_result| {
    if let Ok(message) = message_result {
        if message.is_expressive() {
            match message.get_expressive() {
                Expressive::Bubble(effect) => {
                    match effect {
                        BubbleEffect::Gentle => println!("Sent with Gentle effect"),
                        BubbleEffect::Slam => println!("Sent with Slam effect"),
                        BubbleEffect::Loud => println!("Sent with Loud effect"),
                        BubbleEffect::InvisibleInk => println!("Sent with Invisible Ink"),
                    }
                },
                Expressive::Screen(effect) => {
                    match effect {
                        ScreenEffect::Confetti => println!("Sent with Confetti!"),
                        ScreenEffect::Balloons => println!("Sent with Balloons!"),
                        ScreenEffect::Fireworks => println!("Sent with Fireworks!"),
                        ScreenEffect::Lasers => println!("Sent with Lasers!"),
                        ScreenEffect::Heart => println!("Sent with Heart!"),
                        ScreenEffect::Echo => println!("Sent with Echo!"),
                        ScreenEffect::Spotlight => println!("Sent with Spotlight!"),
                        ScreenEffect::ShootingStar => println!("Sent with Shooting Star!"),
                        ScreenEffect::Sparkles => println!("Sent with Sparkles!"),
                    }
                },
                Expressive::Unknown(id) => println!("Unknown effect: {}", id),
                Expressive::None => {{}},
            }
        }
    }
    Ok::<(), imessage_database::error::table::TableError>(())
}).unwrap();
```

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

### Create Unique Chat Identifiers

Source: https://github.com/reagentx/imessage-exporter/blob/develop/docs/tables/duplicates.md

This Python code illustrates the process of creating unique chat identifiers by mapping sets of participants (identified by 'Person Centric ID') to unique chat IDs. This addresses the many-to-many problem in iMessage conversations.

```python
def create_unique_chat_ids(chats_table, handle_metadata_map):
    """Creates unique chat identifiers based on participants.

    Args:
        chats_table: A list of dictionaries representing the chats table.
        handle_metadata_map: A dictionary mapping Handle ID to metadata string.

    Returns:
        A tuple containing two dictionaries: participants_to_chat_ids and chat_id_to_unique_chat_id.
    """
    # Map Person Centric ID to Handle IDs
    person_centric_to_handle_ids = {}
    for handle_id, metadata in handle_metadata_map.items():
        # This part needs to be inferred or provided from the handle data itself
        # For simplicity, let's assume we can get the Person Centric ID from handle_metadata_map keys or a separate lookup
        # In a real scenario, you'd likely have a direct mapping from Handle ID to Person Centric ID
        pass # Placeholder for actual mapping logic

    # Reconstruct Person Centric IDs from the original handles_data for demonstration
    # In a real application, this mapping would be readily available.
    handle_id_to_person_centric = {
        1: 'A', 2: 'A', 3: 'B'
    }

    participants_to_chat_ids = {}
    for chat in chats_table:
        handle_id = chat['Handle ID']
        person_centric_id = handle_id_to_person_centric.get(handle_id)
        if not person_centric_id:
            continue

        chat_id = chat['Chat ID']
        if person_centric_id not in participants_to_chat_ids:
            participants_to_chat_ids[person_centric_id] = set()
        participants_to_chat_ids[person_centric_id].add(chat_id)

    # Create a mapping from a frozenset of participants to a unique chat ID
    unique_chat_id_counter = 0
    chat_id_to_unique_chat_id = {}
    unique_chat_id_to_participants = {}

    for person_centric_id, chat_ids_set in participants_to_chat_ids.items():
        # For group chats, we need to consider all participants in a chat ID
        # This simplified example assumes one-to-one or direct mapping per person_centric_id
        # A more robust solution would group by Chat ID first, then determine unique participant sets.
        
        # Let's refine to group by Chat ID first to handle group chats correctly
        chat_id_to_participants_set = {}
        for c in chats_table:
            handle_id = c['Handle ID']
            person_centric_id = handle_id_to_person_centric.get(handle_id)
            if not person_centric_id:
                continue
            
            chat_id = c['Chat ID']
            if chat_id not in chat_id_to_participants_set:
                chat_id_to_participants_set[chat_id] = set()
            chat_id_to_participants_set[chat_id].add(person_centric_id)

        # Now map unique sets of participants to a unique chat ID
        unique_chat_id_counter = 0
        unique_chat_id_map = {}
        for chat_id, participants_set in chat_id_to_participants_set.items():
            frozen_participants = frozenset(participants_set)
            if frozen_participants not in unique_chat_id_map:
                unique_chat_id_counter += 1
                unique_chat_id_map[frozen_participants] = unique_chat_id_counter
            chat_id_to_unique_chat_id[chat_id] = unique_chat_id_map[frozen_participants]

    return participants_to_chat_ids, chat_id_to_unique_chat_id

# Example Usage:
chats_data = [
    {'Chat ID': 10, 'Handle ID': 1, 'Group ID': 'A'},
    {'Chat ID': 11, 'Handle ID': 2, 'Group ID': 'A'},
    {'Chat ID': 12, 'Handle ID': 3, 'Group ID': 'B'},
    {'Chat ID': 12, 'Handle ID': 2, 'Group ID': 'B'},
    {'Chat ID': 13, 'Handle ID': 1, 'Group ID': 'B'},
    {'Chat ID': 13, 'Handle ID': 3, 'Group ID': 'B'}
]

handles_map_for_chat = {
    1: 'X, Y',
    2: 'X, Y',
    3: 'Z'
}

participants_to_chats, chat_to_unique_chat = create_unique_chat_ids(chats_data, handles_map_for_chat)

print("Participants to Chat IDs:", participants_to_chats)
print("Chat ID to Unique Chat ID:", chat_to_unique_chat)
# Expected Output (may vary based on internal set ordering and counter): 
# Participants to Chat IDs: {'A': {10, 11}, 'B': {12, 13}}
# Chat ID to Unique Chat ID: {10: 1, 11: 2, 12: 3, 13: 3} (or similar mapping where 12 and 13 map to the same unique ID if participants are identical)

```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.