Struct BaiduNetDiskClient 

pub struct BaiduNetDiskClient { /* private fields */ }

Implementations

impl BaiduNetDiskClient

pub fn builder() -> ClientBuilder

Examples found in repository

examples/user_info.rs (line 10)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("=== Baidu NetDisk User Info Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .app_key("your_app_key")
        .app_secret("your_app_secret")
        .build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("Getting user info...");
    let user_info = client.user().get_user_info(Some("v2")).await?;

    println!("\n=== User Information ===");
    println!("Baidu Name:    {}", user_info.baidu_name);
    println!("NetDisk Name:  {}", user_info.netdisk_name);
    println!("Avatar URL:    {}", user_info.avatar_url);
    println!(
        "VIP Type:      {}",
        match user_info.vip_type {
            0 => "Regular user",
            1 => "VIP member",
            2 => "SVIP super member",
            _ => "Unknown",
        }
    );
    println!("User ID (uk):  {}", user_info.uk);

    Ok(())
}

examples/category.rs (line 13)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let test_dir = "/apps/product";

    println!("=== Baidu NetDisk Category Test ===\n");

    println!("Testing directory: {}\n", test_dir);

    println!("=== Part 1: Global Category Counts (All files) ===");
    println!("----------------------------------------");
    test_global_counts(&client).await?;

    println!("\n\n=== Part 2: Category Counts in {} ===", test_dir);
    println!("----------------------------------------");
    test_directory_counts(&client, &test_dir).await?;

    println!("\n\n=== Part 3: List Files in Each Category ===");
    println!("----------------------------------------");
    test_list_category_files(&client, &test_dir).await?;

    println!("\n\n=== Category Test Completed ===");

    Ok(())
}

examples/upload_file.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk File Upload (Simple) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_file(local_file, remote_path).await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_bytes.rs (line 8)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let remote_path = if args.len() >= 2 {
        &args[1]
    } else {
        "/upload/hello_bytes.txt"
    };

    println!("=== Baidu NetDisk Bytes Upload (Simple) ===");
    println!("Remote path: {}", remote_path);
    println!();

    let test_data = b"Hello from upload_bytes! This is a simple byte array upload test.";
    println!("Uploading {} bytes of data...", test_data.len());

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_bytes(test_data, remote_path).await?;

    println!("Bytes uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_reader.rs (line 9)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let local_file = if args.len() >= 2 {
        &args[1]
    } else {
        println!("Usage: {} <local_file> [remote_path]", args[0]);
        println!("Example: {} test.txt /upload/test.txt", args[0]);
        return Ok(());
    };

    let remote_path = if args.len() >= 3 {
        &args[2]
    } else {
        "/upload/test_reader.txt"
    };

    println!("=== Baidu NetDisk Reader Upload ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let file = std::fs::File::open(local_file)?;
    let metadata = file.metadata()?;
    let file_size = metadata.len();

    println!("File size: {} bytes", file_size);

    let mut reader = BufReader::new(file);

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_reader(&mut reader, file_size, remote_path)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_precreate.rs (line 46)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

Additional examples can be found in:

• examples/upload_file_options.rs
• examples/quota.rs
• examples/list_all.rs
• examples/auth_flow.rs
• examples/search.rs
• examples/token_test.rs
• examples/token_check.rs
• examples/token_refresh.rs
• examples/download.rs
• examples/category_list.rs
• examples/download_compare.rs
• examples/file.rs
• examples/playlist.rs

pub fn authorize(&self) -> &Authorization

Examples found in repository

examples/auth_flow.rs (line 19)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Baidu NetDisk Auth Flow Example ===");
    println!();

    let client = BaiduNetDiskClient::builder()
        .timeout(Duration::from_secs(30))
        .build()?;

    println!("Client created successfully");
    println!();

    println!("Step 1: Getting device code...");
    let device_code = client.authorize().get_device_code().await?;

    println!("Device Code Info:");
    println!("  User Code: {}", device_code.user_code);
    println!("  Verification URL: {}", device_code.verification_url);
    println!("  QR Code URL: {}", device_code.qrcode_url);
    println!("  Interval: {} seconds", device_code.interval);
    println!(
        "  Expires in: {} seconds",
        device_code.expires_at - chrono::Utc::now().timestamp() as u64
    );
    println!();

    println!("Please visit the verification URL above and enter the user code to authorize.");
    println!("Waiting for authorization...");
    println!();

    let max_attempts = 30;
    let mut attempts = 0;

    let access_token = loop {
        attempts += 1;

        if attempts > max_attempts {
            return Err("Max attempts reached, authorization timeout".into());
        }

        println!("Attempt {}/{}", attempts, max_attempts);

        match client.authorize().request_access_token(&device_code).await {
            Ok(Some(token)) => {
                println!();
                println!("✅ Authorization successful!");
                break token;
            }
            Ok(None) => {
                println!("  Authorization pending, waiting...");
                tokio::time::sleep(Duration::from_secs(device_code.interval as u64)).await;
                continue;
            }
            Err(e) => {
                println!("  Error: {}", e);
                tokio::time::sleep(Duration::from_secs(device_code.interval as u64)).await;
                continue;
            }
        }
    };

    println!();
    println!("=== Access Token Info ===");
    println!("Access Token: {}", access_token.access_token);
    println!("Expires in: {} seconds", access_token.expires_in);
    println!("Refresh Token: {}", access_token.refresh_token);
    println!("Scope: {}", access_token.scope);
    println!("Session Key: {}", access_token.session_key);
    println!("Session Secret: {}", access_token.session_secret);
    println!("Acquired At: {}", access_token.acquired_at);
    println!();

    println!("=== Auth Flow Completed Successfully ===");

    Ok(())
}

pub fn token_provider(&self) -> &TokenProvider

Examples found in repository

examples/token_check.rs (line 44)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Validation and Refresh Test ===");
    println!();

    // Create client
    let client = BaiduNetDiskClient::builder().build()?;

    println!("Client created successfully");
    println!();

    // Test 1: Load token from environment
    println!("Test 1: Loading token from environment...");
    client.load_token_from_env()?;

    let token = client.get_valid_token().await?;
    println!("Token loaded successfully: {}", token.access_token);
    println!();

    // Test 2: Check token validity
    println!("Test 2: Checking token validity...");
    println!("Token acquired at: {}", token.acquired_at);
    println!("Token expires in: {} seconds", token.expires_in);
    println!("Token remaining seconds: {}", token.remaining_seconds());
    println!("Token is expired: {}", token.is_expired());

    if !token.is_expired() {
        println!("✓ Token is valid");
    } else {
        println!("✗ Token is expired");
    }
    println!();

    // Test 3: Test needs_refresh logic
    println!("Test 3: Testing needs_refresh logic...");
    let needs_refresh = client.token_provider().needs_refresh()?;
    println!("Token needs refresh: {}", needs_refresh);

    if !needs_refresh {
        println!("✓ Token doesn't need refresh");
    } else {
        println!("✗ Token needs refresh");
    }
    println!();

    // Test 4: Try to get valid token
    println!("Test 4: Getting valid token...");
    match client.get_valid_token().await {
        Ok(valid_token) => {
            println!("✓ Got valid token: {}", valid_token.access_token);
            println!(
                "Token expires in: {} seconds",
                valid_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Failed to get valid token: {}", e);
            println!("Note: This is expected if refresh token is invalid/mock");
        }
    }
    println!();

    // Test 5: Test with an expired token
    println!("Test 5: Testing with expired token...");
    let expired_token = AccessToken {
        access_token: "expired_token".to_string(),
        expires_in: 1, // 1 second
        refresh_token: "mock_refresh_token".to_string(),
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 10, // 10 seconds ago
    };

    client.set_access_token(expired_token.clone())?;
    println!(
        "Expired token remaining seconds: {}",
        expired_token.remaining_seconds()
    );
    println!("Expired token is_expired: {}", expired_token.is_expired());

    if expired_token.is_expired() {
        println!("✓ Expired token correctly identified");
    } else {
        println!("✗ Failed to identify expired token");
    }
    println!();

    println!("=== Test completed ===");
    Ok(())
}

examples/token_refresh.rs (line 34)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Refresh Test ===");
    println!();

    // Create client with auto-refresh enabled
    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(60)
        .build()?;

    println!("Client created successfully");
    println!();

    // Step 1: Load token from environment
    println!("Step 1: Loading token from environment...");
    client.load_token_from_env()?;
    println!("Token loaded successfully");

    let original_token = client.get_valid_token().await?;
    println!("Original Token: {:?}", original_token);
    println!();

    // Step 2: Test manual refresh
    println!("Step 2: Testing manual token refresh...");
    match client.token_provider().refresh_token().await {
        Ok(new_token) => {
            println!("✓ Token refreshed successfully!");
            println!("  New Access Token: {}", new_token.access_token);
            println!("  New Refresh Token: {}", new_token.refresh_token);
            println!("  Expires in: {} seconds", new_token.expires_in);
            println!();

            // Verify the tokens are different
            if new_token.access_token != original_token.access_token {
                println!("✓ Access token changed after refresh");
            } else {
                println!("✗ Access token remains the same");
            }

            // Verify refresh token may have changed
            if new_token.refresh_token != original_token.refresh_token {
                println!("✓ Refresh token changed after refresh");
            } else {
                println!("Note: Refresh token remains the same (may be expected)");
            }
        }
        Err(e) => {
            println!("✗ Failed to refresh token: {}", e);
            println!("Note: This may be due to invalid credentials or network issues");
        }
    }

    println!();

    // Step 3: Test auto-refresh with expired token simulation
    println!("Step 3: Testing auto-refresh behavior...");

    // Create an expired token to test auto-refresh
    let expired_token = AccessToken {
        access_token: "expired_access_token".to_string(),
        expires_in: 60,                                      // 60 seconds
        refresh_token: original_token.refresh_token.clone(), // Use real refresh token
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 3600, // 1 hour ago (expired)
    };

    client.set_access_token(expired_token)?;

    // Now try to get valid token - should trigger auto-refresh
    match client.get_valid_token().await {
        Ok(refreshed_token) => {
            println!("✓ Auto-refresh triggered successfully!");
            println!("  New Access Token: {}", refreshed_token.access_token);
            println!(
                "  Expires in: {} seconds",
                refreshed_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("Note: This may be due to invalid credentials");
        }
    }

    println!();
    println!("=== Refresh test completed ===");
    Ok(())
}

pub fn user(&self) -> &UserClient

Examples found in repository

examples/user_info.rs (line 20)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("=== Baidu NetDisk User Info Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .app_key("your_app_key")
        .app_secret("your_app_secret")
        .build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("Getting user info...");
    let user_info = client.user().get_user_info(Some("v2")).await?;

    println!("\n=== User Information ===");
    println!("Baidu Name:    {}", user_info.baidu_name);
    println!("NetDisk Name:  {}", user_info.netdisk_name);
    println!("Avatar URL:    {}", user_info.avatar_url);
    println!(
        "VIP Type:      {}",
        match user_info.vip_type {
            0 => "Regular user",
            1 => "VIP member",
            2 => "SVIP super member",
            _ => "Unknown",
        }
    );
    println!("User ID (uk):  {}", user_info.uk);

    Ok(())
}

pub fn quota(&self) -> &QuotaClient

Examples found in repository

examples/quota.rs (line 17)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("=== Baidu NetDisk Quota Test ===\n");

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("1. Testing get_quota...");
    let quota = client.quota().get_quota().await?;

    println!("\n=== Basic Quota Information ===");
    println!(
        "Total:    {}",
        baidu_netdisk_sdk::CapacityInfo::format_bytes(quota.total)
    );
    println!(
        "Used:     {}",
        baidu_netdisk_sdk::CapacityInfo::format_bytes(quota.used)
    );
    println!(
        "Free:     {}",
        baidu_netdisk_sdk::CapacityInfo::format_bytes(quota.free)
    );

    println!("\n2. Testing get_quota_with_expire...");
    let capacity = client.quota().get_quota_with_expire().await?;
    println!("\n=== Detailed Capacity Information ===");
    println!("Total:        {}", capacity.format_total());
    println!(
        "Used:         {} ({:.2}%)",
        capacity.format_used(),
        capacity.usage_percentage()
    );
    println!("Free:         {}", capacity.format_free());
    println!(
        "Expired:      {}",
        if capacity.expire { "Yes" } else { "No" }
    );

    println!("\n3. Testing get_capacity (check_free only)...");
    let capacity_free = client.quota().get_capacity(true, false).await?;

    println!("\n=== Capacity with Free Check ===");
    println!("Total:        {}", capacity_free.format_total());
    println!("Used:         {}", capacity_free.format_used());
    println!("Free:         {}", capacity_free.format_free());

    println!("\n4. Testing get_capacity (check_expire only)...");
    let capacity_expire = client.quota().get_capacity(false, true).await?;

    println!("\n=== Capacity with Expire Check ===");
    println!("Total:        {}", capacity_expire.format_total());
    println!("Used:         {}", capacity_expire.format_used());
    println!(
        "Expired:      {}",
        if capacity_expire.expire { "Yes" } else { "No" }
    );

    println!("\n=== All quota tests completed successfully ===");

    Ok(())
}

pub fn file(&self) -> &FileClient

Examples found in repository

examples/category.rs (line 60)

async fn test_global_counts(client: &BaiduNetDiskClient) -> Result<(), Box<dyn std::error::Error>> {
    let categories = [
        (Category::Video, "Video"),
        (Category::Music, "Music"),
        (Category::Image, "Image"),
        (Category::Document, "Document"),
        (Category::Application, "Application"),
        (Category::Other, "Other"),
        (Category::Torrent, "Torrent"),
    ];

    for (category, name) in categories {
        let options = CategorySearchOptions::new()
            .parent_path("/")
            .recursion(1)
            .limit(1);

        match client
            .file()
            .search_category_files_with_options(&category.as_u32().to_string(), options)
            .await
        {
            Ok((_, total)) => {
                println!("  {}: {} files", name, total);
            }
            Err(e) => {
                println!("  {}: Error - {}", name, e);
            }
        }

        wait_for_rate_limit().await;
    }

    Ok(())
}

async fn test_directory_counts(
    client: &BaiduNetDiskClient,
    dir: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let categories = [
        (Category::Video, "Video"),
        (Category::Music, "Music"),
        (Category::Image, "Image"),
        (Category::Document, "Document"),
        (Category::Application, "Application"),
        (Category::Other, "Other"),
        (Category::Torrent, "Torrent"),
    ];

    for (category, name) in categories {
        let options = CategorySearchOptions::new()
            .parent_path(dir)
            .recursion(1)
            .limit(1);

        match client
            .file()
            .search_category_files_with_options(&category.as_u32().to_string(), options)
            .await
        {
            Ok((_, total)) => {
                println!("  {}: {} files", name, total);
            }
            Err(e) => {
                println!("  {}: Error - {}", name, e);
            }
        }

        wait_for_rate_limit().await;
    }

    Ok(())
}

async fn test_list_category_files(
    client: &BaiduNetDiskClient,
    dir: &str,
) -> Result<(), Box<dyn std::error::Error>> {
    let categories = [
        (1, "Video"),
        (2, "Music"),
        (3, "Image"),
        (4, "Document"),
        (5, "Application"),
        (6, "Other"),
        (7, "Torrent"),
    ];

    for (category, name) in categories {
        println!("\n  [{}] Files:", name);

        let options = CategorySearchOptions::new()
            .parent_path(dir)
            .recursion(1)
            .limit(10);

        match client
            .file()
            .search_category_files_with_options(&category.to_string(), options)
            .await
        {
            Ok((files, total)) => {
                if files.is_empty() {
                    println!("    (no files)");
                } else {
                    for file in files.iter().take(5) {
                        let size_str = file
                            .size
                            .map(|s| format!("{:.2} MB", s as f64 / (1024.0 * 1024.0)))
                            .unwrap_or_else(|| "N/A".to_string());
                        println!("    - {} ({})", file.name, size_str);
                    }
                    if files.len() > 5 && total > 5 {
                        println!("    ... and {} more files", total - 5);
                    }
                    println!("    Total in this category: {}", total);
                }
            }
            Err(e) => {
                println!("    Error - {}", e);
            }
        }

        wait_for_rate_limit().await;
    }

    Ok(())
}

examples/list_all.rs (line 40)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let test_dir = "/apps/chapters";
    let page_size = 10;

    println!("=== Baidu NetDisk ListAll Test ===");
    println!("Directory: {}", test_dir);
    println!("Page size: {}\n", page_size);

    let mut start = 0;
    let mut page_num = 1;
    let mut total_files = 0;
    let mut has_more = true;

    while has_more {
        // 使用简化的 list_all 方法，默认开启递归
        match client.file().list_all(test_dir, start, page_size).await {
            Ok(result) => {
                has_more = result.has_more;

                println!("--- Page {} ---", page_num);
                println!("Found {} files in this page", result.list.len());

                for file in &result.list {
                    let size_str = file
                        .size
                        .map(|s| format_size(s))
                        .unwrap_or_else(|| "N/A".to_string());
                    let is_dir = file.isdir.map(|i| i == 1).unwrap_or(false);
                    let file_type = if is_dir { "DIR" } else { "FILE" };

                    println!("  [{}] {} ({})", file_type, file.name, size_str);
                }

                total_files += result.list.len();

                if has_more {
                    println!("\nPress Enter to continue to page {}...", page_num + 1);
                    println!("Next cursor: {:?}", result.cursor);
                    // 使用 cursor 作为下一页的 start，用户无需手动计算
                    if let Some(cursor) = result.cursor {
                        start = cursor as i32;
                    }
                    let mut input = String::new();
                    std::io::stdin().read_line(&mut input)?;
                }
                page_num += 1;
            }
            Err(e) => {
                println!("Error: {}", e);
                break;
            }
        }
    }

    println!("\n=== ListAll Test Completed ===");
    println!("Total files found: {}", total_files);

    Ok(())
}

examples/search.rs (line 60)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("=== Baidu NetDisk Search API Test ===");
    println!();

    // Part 1: Keyword Search (simple)
    println!("--- Part 1: Keyword Search (simple) ---");
    let (files, has_more) = client
        .file()
        .search_files("test", "/")
        .await
        .map_err(|e| format!("Search failed: {}", e))?;
    print_file_list(&files, &format!("Results (has_more: {}):", has_more));
    wait_for_rate_limit().await;

    // Part 2: Keyword Search with category filter
    println!("\n--- Part 2: Keyword Search with Category Filter ---");
    println!("Searching for '*' in category 4 (Documents):");
    let options = SearchOptions::new("/").category(4);

    let (files, has_more) = client
        .file()
        .search_files_with_options("*", options)
        .await
        .map_err(|e| format!("Search failed: {}", e))?;
    print_file_list(&files, &format!("Results (has_more: {}):", has_more));
    wait_for_rate_limit().await;

    // Part 3: Keyword Search with recursion
    println!("\n--- Part 3: Keyword Search with Recursion ---");
    println!("Recursive search for '*':");
    let options = SearchOptions::new("/").recursion(true);
    let (files, has_more) = client
        .file()
        .search_files_with_options("*", options)
        .await
        .map_err(|e| format!("Search failed: {}", e))?;
    print_file_list(&files, &format!("Results (has_more: {}):", has_more));
    wait_for_rate_limit().await;

    // Part 4: Semantic Search (simple)
    println!("\n--- Part 4: Semantic Search (simple query) ---");
    println!("Query: \"find text files\"");
    let files = client
        .file()
        .semantic_search("find text files")
        .await
        .map_err(|e| format!("Semantic search failed: {}", e))?;
    print_file_list(&files, "Results:");

    // Part 5: Semantic Search with options
    println!("\n--- Part 5: Semantic Search with Options ---");
    println!("Query: \"search for images\" (semantic mode)");
    let options = SemanticSearchOptions::new().search_type(1);
    let files = client
        .file()
        .semantic_search_with_options("search for images", options)
        .await
        .map_err(|e| format!("Semantic search failed: {}", e))?;
    print_file_list(&files, "Results:");

    // Part 6: Semantic Search with auto mode
    println!("\n--- Part 6: Semantic Search (auto mode) ---");
    println!("Query: \"video files\" (auto: uses keyword for short queries)");
    let options = SemanticSearchOptions::new().search_type(2);
    let files = client
        .file()
        .semantic_search_with_options("video files", options)
        .await
        .map_err(|e| format!("Semantic search failed: {}", e))?;
    print_file_list(&files, "Results:");

    println!("\n=== Test Completed ===");

    Ok(())
}

examples/download.rs (line 46)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    // Create client
    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    // Load token from environment
    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("=== Baidu NetDisk Download Test ===");
    println!("Enter the remote file path to download (e.g., /upload/test.txt):");

    let stdin = io::stdin();
    let mut reader = stdin.lock();
    let mut input = String::new();
    reader.read_line(&mut input)?;
    let remote_path = input.trim();

    if remote_path.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    // Step 1: Get file info (to obtain fs_id)
    println!("\n--- Step 1: Get file info (to obtain fs_id) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let file_info = client.file().get_file_info(remote_path).await?;
    let file_size = file_info.size.unwrap_or(0);
    let fs_id = file_info.fs_id.ok_or_else(|| "File has no fs_id")?;
    let file_meta = client.file().get_file_meta(fs_id).await?;

    println!("File Info:");
    println!("  Name: {}", file_info.name);
    println!("  Path: {}", file_info.path);
    println!(
        "  Size: {} bytes ({:.2} MB)",
        file_size,
        file_size as f64 / (1024.0 * 1024.0)
    );
    println!("  FS ID: {:?}", file_info.fs_id);

    // Step 2: Single-threaded download (skip for large files > 50MB)
    println!("\n--- Step 2: Single-threaded download ---");
    if file_size > 50 * 1024 * 1024 {
        println!(
            "File size {} bytes exceeds 50MB, skipping single-threaded download...",
            file_size
        );
    } else {
        println!("Press Enter to continue...");
        reader.read_line(&mut String::new())?;

        let single_save_path = format!("./download_single_{}", file_info.name);
        let start_time = Instant::now();

        match client
            .download()
            .download_single(remote_path, &single_save_path)
            .await
        {
            Ok(_) => {
                let duration = start_time.elapsed();
                print_download_stats("Single-threaded", file_size, duration);
                println!("Single-threaded download successful: {}", single_save_path);
            }
            Err(e) => eprintln!("Single-threaded download failed: {}", e),
        }
    }

    // Step 3: Producer-consumer parallel download (queue-based)
    println!("\n--- Step 3: Parallel download (Producer-Consumer queue-based) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let parallel_save_path = format!("./download_parallel_{}", file_info.name);
    let start_time = Instant::now();

    match client
        .download()
        .download_parallel_multi_threaded(&file_meta, &parallel_save_path, Some(12))
        .await
    {
        Ok(_) => {
            let duration = start_time.elapsed();
            print_download_stats("Parallel (Producer-Consumer)", file_size, duration);
            println!("Parallel download successful: {}", parallel_save_path);
        }
        Err(e) => eprintln!("Parallel download failed: {}", e),
    }

    // Step 4: Auto download (recommended)
    println!("\n--- Step 4: Auto download (recommended) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let auto_save_path = format!("./download_auto_{}", file_info.name);
    let start_time = Instant::now();

    match client
        .download()
        .auto_download(remote_path, &auto_save_path)
        .await
    {
        Ok(_) => {
            let duration = start_time.elapsed();
            print_download_stats("Auto download", file_size, duration);
            println!("Auto download successful: {}", auto_save_path);
        }
        Err(e) => eprintln!("Auto download failed: {}", e),
    }

    println!("\n=== Download test completed ===");

    Ok(())
}

examples/category_list.rs (line 42)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let test_dir = "/apps/product";
    let num_per_page = 5;

    println!("=== Baidu NetDisk Fixed Category List Test ===");
    println!("Directory: {}", test_dir);
    println!("Items per page: {}\n", num_per_page);

    println!("--- Part 1: Document List (doclist) ---");
    match client
        .file()
        .list_documents(test_dir, 1, num_per_page)
        .await
    {
        Ok(files) => {
            println!("Found {} documents", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- Part 2: Image List (imagelist) ---");
    match client.file().list_images(test_dir, 1, num_per_page).await {
        Ok(files) => {
            println!("Found {} images", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- Part 3: Video List (videolist) ---");
    match client.file().list_videos(test_dir, 1, num_per_page).await {
        Ok(files) => {
            println!("Found {} videos", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- Part 4: BT List (btlist) ---");
    match client.file().list_torrents(test_dir, 1, num_per_page).await {
        Ok(files) => {
            println!("Found {} torrent files", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n=== Test with Options (recursion=1) ===");
    println!("Directory: {}\n", test_dir);

    println!("--- Document List with recursion ---");
    let options = DocumentListOptions::new(test_dir)
        .recursion(1)
        .num(num_per_page);
    match client.file().list_documents_with_options(options).await {
        Ok(files) => {
            println!("Found {} documents", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- Image List with recursion ---");
    let options = ImageListOptions::new(test_dir)
        .recursion(1)
        .num(num_per_page);
    match client.file().list_images_with_options(options).await {
        Ok(files) => {
            println!("Found {} images", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- Video List with recursion ---");
    let options = VideoListOptions::new(test_dir)
        .recursion(1)
        .num(num_per_page);
    match client.file().list_videos_with_options(options).await {
        Ok(files) => {
            println!("Found {} videos", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }
    wait_for_rate_limit().await;

    println!("\n--- BT List with recursion ---");
    let options = BtListOptions::new(test_dir).recursion(1).num(num_per_page);
    match client.file().list_torrents_with_options(options).await {
        Ok(files) => {
            println!("Found {} torrent files", files.len());
            for file in &files {
                let size_str = file
                    .size
                    .map(|s| format_size(s))
                    .unwrap_or_else(|| "N/A".to_string());
                println!("  - {} ({})", file.name, size_str);
            }
        }
        Err(e) => {
            println!("Error: {}", e);
        }
    }

    println!("\n=== Test Completed ===");

    Ok(())
}

examples/download_compare.rs (line 44)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("=== Baidu NetDisk Download Comparison Test ===");
    println!();
    println!(
        "Enter the number of threads/concurrency to use (recommended: match your CPU core count)"
    );
    println!("Example: 4 for 4 cores, 8 for 8 cores, etc.");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let thread_num: usize = input.trim().parse().unwrap_or(4);
    let concurrency = thread_num * 3;
    println!();
    println!("Thread count: {}", thread_num);
    println!("Concurrency: {}", concurrency);
    println!();

    println!("=== Method 1: Streaming (Futures/Concurrency) ===");
    println!("Enter the remote file path to download:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let remote_path_streaming = input.trim();

    if remote_path_streaming.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    println!("\n--- Step 1: Get file info for Streaming ---");
    let file_info_streaming = client.file().get_file_info(remote_path_streaming).await?;
    let file_size_streaming = file_info_streaming.size.unwrap_or(0);
    let fs_id_streaming = file_info_streaming.fs_id.ok_or("File has no fs_id")?;
    let file_meta_streaming = client.file().get_file_meta(fs_id_streaming).await?;

    println!("File: {}", file_info_streaming.name);
    println!(
        "Size: {} bytes ({:.2} MB)",
        file_size_streaming,
        file_size_streaming as f64 / (1024.0 * 1024.0)
    );
    let total_chunks_streaming = (file_size_streaming + CHUNK_SIZE - 1) / CHUNK_SIZE;
    println!(
        "Chunks: {} ({} bytes each)",
        total_chunks_streaming, CHUNK_SIZE
    );
    println!();

    println!("Press Enter to start Streaming download...");
    std::io::stdin().read_line(&mut String::new())?;

    let streaming_save_path = format!("./download_streaming_{}", file_info_streaming.name);
    let start_streaming = std::time::Instant::now();

    client
        .download()
        .download_streaming_with_meta(
            &file_meta_streaming,
            Path::new(&streaming_save_path),
            concurrency,
        )
        .await?;

    let duration_streaming = start_streaming.elapsed();
    let streaming_mb = file_size_streaming as f64 / (1024.0 * 1024.0);
    let streaming_sec = duration_streaming.as_secs_f64();
    let streaming_speed = streaming_mb / streaming_sec;

    println!();
    println!("=== Method 2: Parallel (Multi-thread) ===");
    println!("Enter the remote file path to download:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let remote_path_parallel = input.trim();

    if remote_path_parallel.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    println!("\n--- Step 1: Get file info for Parallel ---");
    let file_info_parallel = client.file().get_file_info(remote_path_parallel).await?;
    let file_size_parallel = file_info_parallel.size.unwrap_or(0);
    let fs_id_parallel = file_info_parallel.fs_id.ok_or("File has no fs_id")?;
    let file_meta_parallel = client.file().get_file_meta(fs_id_parallel).await?;

    println!("File: {}", file_info_parallel.name);
    println!(
        "Size: {} bytes ({:.2} MB)",
        file_size_parallel,
        file_size_parallel as f64 / (1024.0 * 1024.0)
    );
    let total_chunks_parallel = (file_size_parallel + CHUNK_SIZE - 1) / CHUNK_SIZE;
    println!(
        "Chunks: {} ({} bytes each)",
        total_chunks_parallel, CHUNK_SIZE
    );
    println!();

    println!("Press Enter to start Parallel download...");
    std::io::stdin().read_line(&mut String::new())?;

    let parallel_save_path = format!("./download_parallel_{}", file_info_parallel.name);
    let start_parallel = std::time::Instant::now();

    client
        .download()
        .download_parallel_multi_threaded(
            &file_meta_parallel,
            Path::new(&parallel_save_path),
            Some(thread_num),
        )
        .await?;

    let duration_parallel = start_parallel.elapsed();
    let parallel_mb = file_size_parallel as f64 / (1024.0 * 1024.0);
    let parallel_sec = duration_parallel.as_secs_f64();
    let parallel_speed = parallel_mb / parallel_sec;

    println!();
    println!("╔══════════════════════════════════════════════════════════════════════════╗");
    println!("║                        DOWNLOAD COMPARISON RESULTS                         ║");
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!(
        "║  Threads: {}  │  Concurrency (Streaming): {}  │                  ║",
        thread_num, concurrency
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!("║  Method                      │ Time       │ Speed       │ File           ║");
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!(
        "║  Streaming (Futures)         │ {:>8.2}s  │ {:>8.2} MB/s │ {:.15} ║",
        streaming_sec, streaming_speed, file_info_streaming.name
    );
    println!(
        "║  Parallel (Multi-thread)     │ {:>8.2}s  │ {:>8.2} MB/s │ {:.15} ║",
        parallel_sec, parallel_speed, file_info_parallel.name
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    let speedup = if streaming_sec < parallel_sec {
        parallel_sec / streaming_sec
    } else {
        streaming_sec / parallel_sec
    };
    let faster = if streaming_sec < parallel_sec {
        "Streaming"
    } else {
        "Parallel"
    };
    println!(
        "║  Faster: {} ({:.2}x)                                              ║",
        faster, speedup
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!("║  Note: Parallel mode works best with 6+ cores. On 4 cores, Streaming may  ║");
    println!("║        be 2x faster. Test with your actual core count for best results!   ║");
    println!("╚══════════════════════════════════════════════════════════════════════════╝");

    println!();
    println!("Output files:");
    println!("  Parallel:   {}", parallel_save_path);
    println!("  Streaming:  {}", streaming_save_path);

    Ok(())
}

Additional examples can be found in:

• examples/file.rs

pub fn download(&self) -> &DownloadClient

Examples found in repository

examples/download.rs (line 76)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    // Create client
    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    // Load token from environment
    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("=== Baidu NetDisk Download Test ===");
    println!("Enter the remote file path to download (e.g., /upload/test.txt):");

    let stdin = io::stdin();
    let mut reader = stdin.lock();
    let mut input = String::new();
    reader.read_line(&mut input)?;
    let remote_path = input.trim();

    if remote_path.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    // Step 1: Get file info (to obtain fs_id)
    println!("\n--- Step 1: Get file info (to obtain fs_id) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let file_info = client.file().get_file_info(remote_path).await?;
    let file_size = file_info.size.unwrap_or(0);
    let fs_id = file_info.fs_id.ok_or_else(|| "File has no fs_id")?;
    let file_meta = client.file().get_file_meta(fs_id).await?;

    println!("File Info:");
    println!("  Name: {}", file_info.name);
    println!("  Path: {}", file_info.path);
    println!(
        "  Size: {} bytes ({:.2} MB)",
        file_size,
        file_size as f64 / (1024.0 * 1024.0)
    );
    println!("  FS ID: {:?}", file_info.fs_id);

    // Step 2: Single-threaded download (skip for large files > 50MB)
    println!("\n--- Step 2: Single-threaded download ---");
    if file_size > 50 * 1024 * 1024 {
        println!(
            "File size {} bytes exceeds 50MB, skipping single-threaded download...",
            file_size
        );
    } else {
        println!("Press Enter to continue...");
        reader.read_line(&mut String::new())?;

        let single_save_path = format!("./download_single_{}", file_info.name);
        let start_time = Instant::now();

        match client
            .download()
            .download_single(remote_path, &single_save_path)
            .await
        {
            Ok(_) => {
                let duration = start_time.elapsed();
                print_download_stats("Single-threaded", file_size, duration);
                println!("Single-threaded download successful: {}", single_save_path);
            }
            Err(e) => eprintln!("Single-threaded download failed: {}", e),
        }
    }

    // Step 3: Producer-consumer parallel download (queue-based)
    println!("\n--- Step 3: Parallel download (Producer-Consumer queue-based) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let parallel_save_path = format!("./download_parallel_{}", file_info.name);
    let start_time = Instant::now();

    match client
        .download()
        .download_parallel_multi_threaded(&file_meta, &parallel_save_path, Some(12))
        .await
    {
        Ok(_) => {
            let duration = start_time.elapsed();
            print_download_stats("Parallel (Producer-Consumer)", file_size, duration);
            println!("Parallel download successful: {}", parallel_save_path);
        }
        Err(e) => eprintln!("Parallel download failed: {}", e),
    }

    // Step 4: Auto download (recommended)
    println!("\n--- Step 4: Auto download (recommended) ---");
    println!("Press Enter to continue...");
    reader.read_line(&mut String::new())?;

    let auto_save_path = format!("./download_auto_{}", file_info.name);
    let start_time = Instant::now();

    match client
        .download()
        .auto_download(remote_path, &auto_save_path)
        .await
    {
        Ok(_) => {
            let duration = start_time.elapsed();
            print_download_stats("Auto download", file_size, duration);
            println!("Auto download successful: {}", auto_save_path);
        }
        Err(e) => eprintln!("Auto download failed: {}", e),
    }

    println!("\n=== Download test completed ===");

    Ok(())
}

examples/download_compare.rs (line 69)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("=== Baidu NetDisk Download Comparison Test ===");
    println!();
    println!(
        "Enter the number of threads/concurrency to use (recommended: match your CPU core count)"
    );
    println!("Example: 4 for 4 cores, 8 for 8 cores, etc.");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let thread_num: usize = input.trim().parse().unwrap_or(4);
    let concurrency = thread_num * 3;
    println!();
    println!("Thread count: {}", thread_num);
    println!("Concurrency: {}", concurrency);
    println!();

    println!("=== Method 1: Streaming (Futures/Concurrency) ===");
    println!("Enter the remote file path to download:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let remote_path_streaming = input.trim();

    if remote_path_streaming.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    println!("\n--- Step 1: Get file info for Streaming ---");
    let file_info_streaming = client.file().get_file_info(remote_path_streaming).await?;
    let file_size_streaming = file_info_streaming.size.unwrap_or(0);
    let fs_id_streaming = file_info_streaming.fs_id.ok_or("File has no fs_id")?;
    let file_meta_streaming = client.file().get_file_meta(fs_id_streaming).await?;

    println!("File: {}", file_info_streaming.name);
    println!(
        "Size: {} bytes ({:.2} MB)",
        file_size_streaming,
        file_size_streaming as f64 / (1024.0 * 1024.0)
    );
    let total_chunks_streaming = (file_size_streaming + CHUNK_SIZE - 1) / CHUNK_SIZE;
    println!(
        "Chunks: {} ({} bytes each)",
        total_chunks_streaming, CHUNK_SIZE
    );
    println!();

    println!("Press Enter to start Streaming download...");
    std::io::stdin().read_line(&mut String::new())?;

    let streaming_save_path = format!("./download_streaming_{}", file_info_streaming.name);
    let start_streaming = std::time::Instant::now();

    client
        .download()
        .download_streaming_with_meta(
            &file_meta_streaming,
            Path::new(&streaming_save_path),
            concurrency,
        )
        .await?;

    let duration_streaming = start_streaming.elapsed();
    let streaming_mb = file_size_streaming as f64 / (1024.0 * 1024.0);
    let streaming_sec = duration_streaming.as_secs_f64();
    let streaming_speed = streaming_mb / streaming_sec;

    println!();
    println!("=== Method 2: Parallel (Multi-thread) ===");
    println!("Enter the remote file path to download:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let remote_path_parallel = input.trim();

    if remote_path_parallel.is_empty() {
        eprintln!("Error: File path cannot be empty");
        return Ok(());
    }

    println!("\n--- Step 1: Get file info for Parallel ---");
    let file_info_parallel = client.file().get_file_info(remote_path_parallel).await?;
    let file_size_parallel = file_info_parallel.size.unwrap_or(0);
    let fs_id_parallel = file_info_parallel.fs_id.ok_or("File has no fs_id")?;
    let file_meta_parallel = client.file().get_file_meta(fs_id_parallel).await?;

    println!("File: {}", file_info_parallel.name);
    println!(
        "Size: {} bytes ({:.2} MB)",
        file_size_parallel,
        file_size_parallel as f64 / (1024.0 * 1024.0)
    );
    let total_chunks_parallel = (file_size_parallel + CHUNK_SIZE - 1) / CHUNK_SIZE;
    println!(
        "Chunks: {} ({} bytes each)",
        total_chunks_parallel, CHUNK_SIZE
    );
    println!();

    println!("Press Enter to start Parallel download...");
    std::io::stdin().read_line(&mut String::new())?;

    let parallel_save_path = format!("./download_parallel_{}", file_info_parallel.name);
    let start_parallel = std::time::Instant::now();

    client
        .download()
        .download_parallel_multi_threaded(
            &file_meta_parallel,
            Path::new(&parallel_save_path),
            Some(thread_num),
        )
        .await?;

    let duration_parallel = start_parallel.elapsed();
    let parallel_mb = file_size_parallel as f64 / (1024.0 * 1024.0);
    let parallel_sec = duration_parallel.as_secs_f64();
    let parallel_speed = parallel_mb / parallel_sec;

    println!();
    println!("╔══════════════════════════════════════════════════════════════════════════╗");
    println!("║                        DOWNLOAD COMPARISON RESULTS                         ║");
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!(
        "║  Threads: {}  │  Concurrency (Streaming): {}  │                  ║",
        thread_num, concurrency
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!("║  Method                      │ Time       │ Speed       │ File           ║");
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!(
        "║  Streaming (Futures)         │ {:>8.2}s  │ {:>8.2} MB/s │ {:.15} ║",
        streaming_sec, streaming_speed, file_info_streaming.name
    );
    println!(
        "║  Parallel (Multi-thread)     │ {:>8.2}s  │ {:>8.2} MB/s │ {:.15} ║",
        parallel_sec, parallel_speed, file_info_parallel.name
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    let speedup = if streaming_sec < parallel_sec {
        parallel_sec / streaming_sec
    } else {
        streaming_sec / parallel_sec
    };
    let faster = if streaming_sec < parallel_sec {
        "Streaming"
    } else {
        "Parallel"
    };
    println!(
        "║  Faster: {} ({:.2}x)                                              ║",
        faster, speedup
    );
    println!("╠══════════════════════════════════════════════════════════════════════════╣");
    println!("║  Note: Parallel mode works best with 6+ cores. On 4 cores, Streaming may  ║");
    println!("║        be 2x faster. Test with your actual core count for best results!   ║");
    println!("╚══════════════════════════════════════════════════════════════════════════╝");

    println!();
    println!("Output files:");
    println!("  Parallel:   {}", parallel_save_path);
    println!("  Streaming:  {}", streaming_save_path);

    Ok(())
}

pub fn upload(&self) -> &UploadClient

Examples found in repository

examples/upload_file.rs (line 32)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk File Upload (Simple) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_file(local_file, remote_path).await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_bytes.rs (line 31)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let remote_path = if args.len() >= 2 {
        &args[1]
    } else {
        "/upload/hello_bytes.txt"
    };

    println!("=== Baidu NetDisk Bytes Upload (Simple) ===");
    println!("Remote path: {}", remote_path);
    println!();

    let test_data = b"Hello from upload_bytes! This is a simple byte array upload test.";
    println!("Uploading {} bytes of data...", test_data.len());

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_bytes(test_data, remote_path).await?;

    println!("Bytes uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_reader.rs (line 47)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let local_file = if args.len() >= 2 {
        &args[1]
    } else {
        println!("Usage: {} <local_file> [remote_path]", args[0]);
        println!("Example: {} test.txt /upload/test.txt", args[0]);
        return Ok(());
    };

    let remote_path = if args.len() >= 3 {
        &args[2]
    } else {
        "/upload/test_reader.txt"
    };

    println!("=== Baidu NetDisk Reader Upload ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let file = std::fs::File::open(local_file)?;
    let metadata = file.metadata()?;
    let file_size = metadata.len();

    println!("File size: {} bytes", file_size);

    let mut reader = BufReader::new(file);

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_reader(&mut reader, file_size, remote_path)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_precreate.rs (line 82)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

examples/upload_file_options.rs (line 55)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!(
            "Usage: {} <local_file> <remote_path> [chunk_size] [concurrency]",
            args[0]
        );
        println!("Example: {} test.mp4 /upload/video.mp4 8388608 20", args[0]);
        println!("  - chunk_size: bytes per chunk (default: 4194304 = 4MB)");
        println!("  - concurrency: parallel uploads (default: 10)");
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    let chunk_size: usize = args
        .get(3)
        .and_then(|s| s.parse().ok())
        .unwrap_or(4 * 1024 * 1024);
    let concurrency: usize = args.get(4).and_then(|s| s.parse().ok()).unwrap_or(10);

    let options = SimpleUploadOptions::default()
        .chunk_size(chunk_size)
        .max_concurrency(concurrency);

    println!("=== Baidu NetDisk File Upload (Custom Options) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!(
        "Chunk size: {} bytes ({:.2} MB)",
        chunk_size,
        chunk_size as f64 / 1024.0 / 1024.0
    );
    println!("Concurrency: {}", concurrency);
    println!();

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_file_with_options(local_file, remote_path, options)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

pub fn playlist(&self) -> &PlaylistClient

Examples found in repository

examples/playlist.rs (line 26)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::init();

    println!("=== Baidu NetDisk Playlist Test ===\n");

    // Create client - will automatically load from .env file
    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    // Load token from environment variables
    client.load_token_from_env()?;
    info!("Token loaded successfully");

    // === Part 1: Get Playlist List ===
    println!("=== Part 1: Get Playlist List ===");
    println!("This will fetch all playlists from your Baidu NetDisk");
    wait_for_enter();

    let playlists = match client.playlist().get_playlist_list().await {
        Ok(pl) => {
            println!("✓ Successfully retrieved playlist list!");
            println!(
                "  Has more: {}",
                if pl.has_more == 1 { "Yes" } else { "No" }
            );
            println!("  Found {} playlist(s):", pl.list.len());
            for (idx, playlist) in pl.list.iter().enumerate() {
                println!("    {}. {}", idx + 1, playlist.name);
                println!("       mb_id: {}", playlist.mb_id);
                println!("       file_count: {}", playlist.file_count);
                println!("       btype: {}", playlist.btype);
                println!("       bstype: {}", playlist.bstype);
                println!("       ctime: {}", playlist.ctime);
                println!("       mtime: {}", playlist.mtime);
            }
            Some(pl)
        }
        Err(e) => {
            println!("! Failed to get playlist list: {}", e);
            None
        }
    };

    // === Part 2: Get Playlist File List ===
    println!("\n=== Part 2: Get Playlist File List ===");
    println!("mb_id is the unique identifier for a playlist (numeric).");
    if playlists.is_some() && !playlists.as_ref().unwrap().list.is_empty() {
        println!("Available playlists, please select one's mb_id:");
        for (idx, playlist) in playlists.as_ref().unwrap().list.iter().enumerate() {
            println!(
                "  {}. {} - mb_id: {}",
                idx + 1,
                playlist.name,
                playlist.mb_id
            );
        }
    }
    println!("Please enter mb_id, or press Enter to skip:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let input_trimmed = input.trim();

    let playlist_mb_id = if input_trimmed.is_empty() && playlists.is_some() {
        // If user just pressed enter and we have playlists, use the first one
        println!("  No input provided, using the first playlist...");
        playlists
            .as_ref()
            .and_then(|pl| pl.list.first())
            .map(|p| p.mb_id)
    } else {
        // Try to parse as number
        match input_trimmed.parse::<u64>() {
            Ok(mb_id) => Some(mb_id),
            Err(_) => {
                println!("  Invalid input, please enter a valid mb_id");
                None
            }
        }
    };

    let playlist_files = if let Some(mb_id) = playlist_mb_id {
        println!("\nGetting files from playlist with mb_id: {}", mb_id);
        wait_for_enter();

        match client.playlist().get_playlist_file_list(mb_id).await {
            Ok(pl_files) => {
                println!("✓ Successfully retrieved playlist file list!");
                println!(
                    "  Has more: {}",
                    if pl_files.has_more == 1 { "Yes" } else { "No" }
                );
                println!("  Found {} file(s) in playlist:", pl_files.list.len());
                for (idx, file) in pl_files.list.iter().enumerate() {
                    println!(
                        "    {}. {}",
                        idx + 1,
                        file.server_filename.as_deref().unwrap_or("(no name)")
                    );
                    println!("       fs_id: {}", file.fs_id);
                    println!("       path: {}", file.path);
                    if let Some(size) = &file.size {
                        println!("       size: {}", size);
                    }
                    if let Some(category) = &file.category {
                        println!("       category: {}", category);
                    }
                    if let Some(isdir) = &file.isdir {
                        println!("       isdir: {}", isdir);
                    }
                }
                Some(pl_files)
            }
            Err(e) => {
                println!("! Failed to get playlist file list: {}", e);
                None
            }
        }
    } else {
        println!("  Skipping playlist file list as no valid mb_id was provided");
        None
    };

    // === Part 3-4: Get Media and Check M3U8 Generation ===
    println!("\n=== Part 3-4: Get Media and Check M3U8 Generation ===");
    println!("Enter the path of the media file to get playback info:");
    let mut input = String::new();
    std::io::stdin().read_line(&mut input)?;
    let media_path = input.trim();

    println!("\nEnter media type (e.g., M3U8_MP3_128, M3U8_AUTO_720, M3U8_AUTO_1080) or press Enter for default:");
    let mut media_type_input = String::new();
    std::io::stdin().read_line(&mut media_type_input)?;
    let media_type = if media_type_input.trim().is_empty() {
        "M3U8_AUTO_1080".to_string()
    } else {
        media_type_input.trim().to_string()
    };

    let (_selected_fs_id, selected_path) = if media_path.is_empty() && playlist_files.is_some() {
        // If user just pressed enter and we have files, use the first one
        println!("  No input provided, using the first file in playlist...");
        let file = playlist_files.as_ref().and_then(|pf| pf.list.first());
        (
            file.and_then(|f| f.fs_id.parse::<u64>().ok()),
            file.map(|f| f.path.as_str()),
        )
    } else {
        (None, Some(media_path))
    };

    let target_path = selected_path.unwrap_or_default().to_string();
    if !target_path.is_empty() {
        println!("\nStarting m3u8 check process with type: {}", media_type);
        println!("Path: {}", target_path);
        println!("Press Enter to check, any other key + Enter to skip");

        let mut attempts = 0;
        let max_attempts = 100;
        let mut last_content_len = 0;

        loop {
            // Wait for user to press enter
            let mut user_input = String::new();
            std::io::stdin().read_line(&mut user_input)?;
            if !user_input.trim().is_empty() && user_input.trim() != "y" && user_input.trim() != "Y"
            {
                println!("  Skipping further checks");
                break;
            }

            attempts += 1;
            println!("\n=== Check attempt {}/{} ===", attempts, max_attempts);

            // Try to get m3u8 content directly
            match client
                .playlist()
                .get_media_m3u8_content(&target_path, &media_type)
                .await
            {
                Ok(content) => {
                    let len = content.len();
                    let has_end_list = content.contains("#EXT-X-ENDLIST");

                    println!("✓ Got m3u8 content!");
                    println!("  Length: {} bytes", len);
                    println!(
                        "  Has #EXT-X-ENDLIST: {}",
                        if has_end_list { "Yes" } else { "No" }
                    );

                    if len > last_content_len {
                        println!("  Content is growing (was {} bytes)", last_content_len);
                        last_content_len = len;
                    } else if len > 0 && len == last_content_len {
                        println!("  Content size unchanged");
                    }

                    // Show preview
                    let preview_lines = content.lines().take(20);
                    println!("\n  Preview:");
                    for line in preview_lines {
                        println!("    {}", line);
                    }
                    if content.lines().count() > 20 {
                        println!("    ... ({} more lines)", content.lines().count() - 20);
                    }

                    if has_end_list {
                        println!("\n✅ Media is fully transcoded! Done.");
                        break;
                    } else {
                        println!("\n⏳ Media still transcoding... Press Enter to check again");
                    }
                }
                Err(e) => {
                    println!("❌ Error getting m3u8: {}", e);
                    println!("  Stopping check process");
                    break;
                }
            }

            if attempts >= max_attempts {
                println!("\n⚠️ Max attempts reached. Giving up.");
                break;
            }
        }
    } else {
        println!("  Skipping as no valid path was provided");
    }

    // === Part 5: Using Quality Enums ===
    println!("\n=== Part 5: Using Quality Enums ===");
    println!("Test the new VideoQuality and AudioQuality enums? (Y/n):");
    let mut enum_test_input = String::new();
    std::io::stdin().read_line(&mut enum_test_input)?;

    if enum_test_input.trim().to_lowercase() != "n" {
        println!("\nAvailable video qualities for different VIP levels:");
        println!("  VIP 0-1: {:?}", VideoQuality::available_for_vip_level(0));
        println!("  VIP 2+: {:?}", VideoQuality::available_for_vip_level(2));

        println!("\nHighest quality for each level:");
        println!(
            "  VIP 0: {:?} ({})",
            VideoQuality::highest_for_vip_level(0),
            VideoQuality::highest_for_vip_level(0).to_media_type()
        );
        println!(
            "  VIP 2: {:?} ({})",
            VideoQuality::highest_for_vip_level(2),
            VideoQuality::highest_for_vip_level(2).to_media_type()
        );

        // Ask user to test enum methods
        println!("\nTest enum-based m3u8 methods? (Y/n):");
        let mut enum_m3u8_input = String::new();
        std::io::stdin().read_line(&mut enum_m3u8_input)?;

        if enum_m3u8_input.trim().to_lowercase() != "n" {
            println!("\nEnter media file path:");
            let mut enum_path_input = String::new();
            std::io::stdin().read_line(&mut enum_path_input)?;
            let enum_path = enum_path_input.trim();

            if !enum_path.is_empty() {
                println!("\nSelect video quality (1=480P, 2=720P, 3=1080P, or press Enter for highest VIP 2):");
                let mut quality_input = String::new();
                std::io::stdin().read_line(&mut quality_input)?;

                let quality = match quality_input.trim() {
                    "1" => VideoQuality::Quality480P,
                    "2" => VideoQuality::Quality720P,
                    "3" => VideoQuality::Quality1080P,
                    _ => VideoQuality::highest_for_vip_level(2), // Default to highest for VIP 2
                };

                println!(
                    "\nUsing quality: {:?} ({})",
                    quality,
                    quality.to_media_type()
                );
                println!("Getting m3u8...");
                wait_for_enter();

                match client.playlist().get_video_m3u8(enum_path, quality).await {
                    Ok(content) => {
                        println!("✓ Successfully got m3u8 content!");
                        println!("  Length: {} bytes", content.len());
                        println!(
                            "  Has #EXT-X-ENDLIST: {}",
                            content.contains("#EXT-X-ENDLIST")
                        );
                    }
                    Err(e) => {
                        println!("! Failed to get m3u8: {}", e);
                    }
                }
            }
        }
    }

    println!("\n=== All playlist tests completed! ===");

    Ok(())
}

pub fn config(&self) -> &ClientConfig

pub async fn get_valid_token(&self) -> NetDiskResult<AccessToken>

Examples found in repository

examples/token_test.rs (line 36)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Baidu NetDisk Token Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(300)
        .build()?;

    println!("--- Part 1: Create AccessToken using builder ---");
    let token = AccessToken::new(
        "your_access_token".to_string(),
        "your_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
    );
    println!("✓ Created AccessToken");
    println!("  Valid for: {} seconds", token.remaining_seconds());

    println!("\n--- Part 2: Load Token from Environment ---");
    client.load_token_from_env()?;

    match client.get_valid_token().await {
        Ok(token) => {
            println!("✓ Token loaded from environment");
            println!("  Scope: {}", token.scope);
            println!("  Valid for: {} seconds", token.remaining_seconds());
        }
        Err(e) => {
            println!("✗ Failed to load token: {}", e);
            println!("\nSet these environment variables:");
            println!("  BD_NETDISK_ACCESS_TOKEN");
            println!("  BD_NETDISK_REFRESH_TOKEN");
            println!("  BD_NETDISK_EXPIRES_IN");
        }
    }

    println!("\n--- Part 3: Validate Token Status ---");
    match client.validate_token() {
        Ok(status) => match status {
            TokenStatus::Valid => println!("✓ Token is valid"),
            TokenStatus::ExpiringSoon => println!("⚠ Token is expiring soon (< 5 min)"),
            TokenStatus::Expired => println!("✗ Token is expired"),
        },
        Err(e) => println!("✗ No token set: {}", e),
    }

    println!("\n--- Part 4: Test Expired Token Auto-Refresh ---");
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();

    let expired_token = AccessToken::with_all(
        "test_access_token".to_string(),
        "test_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
        String::new(),
        String::new(),
        now - 2592000 - 3600,
    );

    println!("Created expired token:");
    println!("  Acquired: {} seconds ago", 2592000 + 3600);
    match expired_token.validate() {
        TokenStatus::Expired => println!("  Status: Expired ✓"),
        _ => println!("  Status: Unexpected"),
    }

    client.set_access_token(expired_token)?;

    println!("\nAttempting to get valid token (will try auto-refresh)...");
    match client.get_valid_token().await {
        Ok(new_token) => {
            println!("✓ Auto-refresh succeeded!");
            println!(
                "  New token valid for: {} seconds",
                new_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("  → Need to re-authenticate via device code flow");
        }
    }

    println!("\n=== Test Complete ===");
    Ok(())
}

examples/token_check.rs (line 24)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Validation and Refresh Test ===");
    println!();

    // Create client
    let client = BaiduNetDiskClient::builder().build()?;

    println!("Client created successfully");
    println!();

    // Test 1: Load token from environment
    println!("Test 1: Loading token from environment...");
    client.load_token_from_env()?;

    let token = client.get_valid_token().await?;
    println!("Token loaded successfully: {}", token.access_token);
    println!();

    // Test 2: Check token validity
    println!("Test 2: Checking token validity...");
    println!("Token acquired at: {}", token.acquired_at);
    println!("Token expires in: {} seconds", token.expires_in);
    println!("Token remaining seconds: {}", token.remaining_seconds());
    println!("Token is expired: {}", token.is_expired());

    if !token.is_expired() {
        println!("✓ Token is valid");
    } else {
        println!("✗ Token is expired");
    }
    println!();

    // Test 3: Test needs_refresh logic
    println!("Test 3: Testing needs_refresh logic...");
    let needs_refresh = client.token_provider().needs_refresh()?;
    println!("Token needs refresh: {}", needs_refresh);

    if !needs_refresh {
        println!("✓ Token doesn't need refresh");
    } else {
        println!("✗ Token needs refresh");
    }
    println!();

    // Test 4: Try to get valid token
    println!("Test 4: Getting valid token...");
    match client.get_valid_token().await {
        Ok(valid_token) => {
            println!("✓ Got valid token: {}", valid_token.access_token);
            println!(
                "Token expires in: {} seconds",
                valid_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Failed to get valid token: {}", e);
            println!("Note: This is expected if refresh token is invalid/mock");
        }
    }
    println!();

    // Test 5: Test with an expired token
    println!("Test 5: Testing with expired token...");
    let expired_token = AccessToken {
        access_token: "expired_token".to_string(),
        expires_in: 1, // 1 second
        refresh_token: "mock_refresh_token".to_string(),
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 10, // 10 seconds ago
    };

    client.set_access_token(expired_token.clone())?;
    println!(
        "Expired token remaining seconds: {}",
        expired_token.remaining_seconds()
    );
    println!("Expired token is_expired: {}", expired_token.is_expired());

    if expired_token.is_expired() {
        println!("✓ Expired token correctly identified");
    } else {
        println!("✗ Failed to identify expired token");
    }
    println!();

    println!("=== Test completed ===");
    Ok(())
}

examples/token_refresh.rs (line 28)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Refresh Test ===");
    println!();

    // Create client with auto-refresh enabled
    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(60)
        .build()?;

    println!("Client created successfully");
    println!();

    // Step 1: Load token from environment
    println!("Step 1: Loading token from environment...");
    client.load_token_from_env()?;
    println!("Token loaded successfully");

    let original_token = client.get_valid_token().await?;
    println!("Original Token: {:?}", original_token);
    println!();

    // Step 2: Test manual refresh
    println!("Step 2: Testing manual token refresh...");
    match client.token_provider().refresh_token().await {
        Ok(new_token) => {
            println!("✓ Token refreshed successfully!");
            println!("  New Access Token: {}", new_token.access_token);
            println!("  New Refresh Token: {}", new_token.refresh_token);
            println!("  Expires in: {} seconds", new_token.expires_in);
            println!();

            // Verify the tokens are different
            if new_token.access_token != original_token.access_token {
                println!("✓ Access token changed after refresh");
            } else {
                println!("✗ Access token remains the same");
            }

            // Verify refresh token may have changed
            if new_token.refresh_token != original_token.refresh_token {
                println!("✓ Refresh token changed after refresh");
            } else {
                println!("Note: Refresh token remains the same (may be expected)");
            }
        }
        Err(e) => {
            println!("✗ Failed to refresh token: {}", e);
            println!("Note: This may be due to invalid credentials or network issues");
        }
    }

    println!();

    // Step 3: Test auto-refresh with expired token simulation
    println!("Step 3: Testing auto-refresh behavior...");

    // Create an expired token to test auto-refresh
    let expired_token = AccessToken {
        access_token: "expired_access_token".to_string(),
        expires_in: 60,                                      // 60 seconds
        refresh_token: original_token.refresh_token.clone(), // Use real refresh token
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 3600, // 1 hour ago (expired)
    };

    client.set_access_token(expired_token)?;

    // Now try to get valid token - should trigger auto-refresh
    match client.get_valid_token().await {
        Ok(refreshed_token) => {
            println!("✓ Auto-refresh triggered successfully!");
            println!("  New Access Token: {}", refreshed_token.access_token);
            println!(
                "  Expires in: {} seconds",
                refreshed_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("Note: This may be due to invalid credentials");
        }
    }

    println!();
    println!("=== Refresh test completed ===");
    Ok(())
}

pub fn set_access_token(&self, token: AccessToken) -> NetDiskResult<()>

Examples found in repository

examples/token_test.rs (line 84)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Baidu NetDisk Token Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(300)
        .build()?;

    println!("--- Part 1: Create AccessToken using builder ---");
    let token = AccessToken::new(
        "your_access_token".to_string(),
        "your_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
    );
    println!("✓ Created AccessToken");
    println!("  Valid for: {} seconds", token.remaining_seconds());

    println!("\n--- Part 2: Load Token from Environment ---");
    client.load_token_from_env()?;

    match client.get_valid_token().await {
        Ok(token) => {
            println!("✓ Token loaded from environment");
            println!("  Scope: {}", token.scope);
            println!("  Valid for: {} seconds", token.remaining_seconds());
        }
        Err(e) => {
            println!("✗ Failed to load token: {}", e);
            println!("\nSet these environment variables:");
            println!("  BD_NETDISK_ACCESS_TOKEN");
            println!("  BD_NETDISK_REFRESH_TOKEN");
            println!("  BD_NETDISK_EXPIRES_IN");
        }
    }

    println!("\n--- Part 3: Validate Token Status ---");
    match client.validate_token() {
        Ok(status) => match status {
            TokenStatus::Valid => println!("✓ Token is valid"),
            TokenStatus::ExpiringSoon => println!("⚠ Token is expiring soon (< 5 min)"),
            TokenStatus::Expired => println!("✗ Token is expired"),
        },
        Err(e) => println!("✗ No token set: {}", e),
    }

    println!("\n--- Part 4: Test Expired Token Auto-Refresh ---");
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();

    let expired_token = AccessToken::with_all(
        "test_access_token".to_string(),
        "test_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
        String::new(),
        String::new(),
        now - 2592000 - 3600,
    );

    println!("Created expired token:");
    println!("  Acquired: {} seconds ago", 2592000 + 3600);
    match expired_token.validate() {
        TokenStatus::Expired => println!("  Status: Expired ✓"),
        _ => println!("  Status: Unexpected"),
    }

    client.set_access_token(expired_token)?;

    println!("\nAttempting to get valid token (will try auto-refresh)...");
    match client.get_valid_token().await {
        Ok(new_token) => {
            println!("✓ Auto-refresh succeeded!");
            println!(
                "  New token valid for: {} seconds",
                new_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("  → Need to re-authenticate via device code flow");
        }
    }

    println!("\n=== Test Complete ===");
    Ok(())
}

examples/token_check.rs (line 87)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Validation and Refresh Test ===");
    println!();

    // Create client
    let client = BaiduNetDiskClient::builder().build()?;

    println!("Client created successfully");
    println!();

    // Test 1: Load token from environment
    println!("Test 1: Loading token from environment...");
    client.load_token_from_env()?;

    let token = client.get_valid_token().await?;
    println!("Token loaded successfully: {}", token.access_token);
    println!();

    // Test 2: Check token validity
    println!("Test 2: Checking token validity...");
    println!("Token acquired at: {}", token.acquired_at);
    println!("Token expires in: {} seconds", token.expires_in);
    println!("Token remaining seconds: {}", token.remaining_seconds());
    println!("Token is expired: {}", token.is_expired());

    if !token.is_expired() {
        println!("✓ Token is valid");
    } else {
        println!("✗ Token is expired");
    }
    println!();

    // Test 3: Test needs_refresh logic
    println!("Test 3: Testing needs_refresh logic...");
    let needs_refresh = client.token_provider().needs_refresh()?;
    println!("Token needs refresh: {}", needs_refresh);

    if !needs_refresh {
        println!("✓ Token doesn't need refresh");
    } else {
        println!("✗ Token needs refresh");
    }
    println!();

    // Test 4: Try to get valid token
    println!("Test 4: Getting valid token...");
    match client.get_valid_token().await {
        Ok(valid_token) => {
            println!("✓ Got valid token: {}", valid_token.access_token);
            println!(
                "Token expires in: {} seconds",
                valid_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Failed to get valid token: {}", e);
            println!("Note: This is expected if refresh token is invalid/mock");
        }
    }
    println!();

    // Test 5: Test with an expired token
    println!("Test 5: Testing with expired token...");
    let expired_token = AccessToken {
        access_token: "expired_token".to_string(),
        expires_in: 1, // 1 second
        refresh_token: "mock_refresh_token".to_string(),
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 10, // 10 seconds ago
    };

    client.set_access_token(expired_token.clone())?;
    println!(
        "Expired token remaining seconds: {}",
        expired_token.remaining_seconds()
    );
    println!("Expired token is_expired: {}", expired_token.is_expired());

    if expired_token.is_expired() {
        println!("✓ Expired token correctly identified");
    } else {
        println!("✗ Failed to identify expired token");
    }
    println!();

    println!("=== Test completed ===");
    Ok(())
}

examples/token_refresh.rs (line 82)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Initialize logger
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Token Refresh Test ===");
    println!();

    // Create client with auto-refresh enabled
    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(60)
        .build()?;

    println!("Client created successfully");
    println!();

    // Step 1: Load token from environment
    println!("Step 1: Loading token from environment...");
    client.load_token_from_env()?;
    println!("Token loaded successfully");

    let original_token = client.get_valid_token().await?;
    println!("Original Token: {:?}", original_token);
    println!();

    // Step 2: Test manual refresh
    println!("Step 2: Testing manual token refresh...");
    match client.token_provider().refresh_token().await {
        Ok(new_token) => {
            println!("✓ Token refreshed successfully!");
            println!("  New Access Token: {}", new_token.access_token);
            println!("  New Refresh Token: {}", new_token.refresh_token);
            println!("  Expires in: {} seconds", new_token.expires_in);
            println!();

            // Verify the tokens are different
            if new_token.access_token != original_token.access_token {
                println!("✓ Access token changed after refresh");
            } else {
                println!("✗ Access token remains the same");
            }

            // Verify refresh token may have changed
            if new_token.refresh_token != original_token.refresh_token {
                println!("✓ Refresh token changed after refresh");
            } else {
                println!("Note: Refresh token remains the same (may be expected)");
            }
        }
        Err(e) => {
            println!("✗ Failed to refresh token: {}", e);
            println!("Note: This may be due to invalid credentials or network issues");
        }
    }

    println!();

    // Step 3: Test auto-refresh with expired token simulation
    println!("Step 3: Testing auto-refresh behavior...");

    // Create an expired token to test auto-refresh
    let expired_token = AccessToken {
        access_token: "expired_access_token".to_string(),
        expires_in: 60,                                      // 60 seconds
        refresh_token: original_token.refresh_token.clone(), // Use real refresh token
        scope: "basic netdisk".to_string(),
        session_key: "".to_string(),
        session_secret: "".to_string(),
        acquired_at: SystemTime::now()
            .duration_since(UNIX_EPOCH)
            .unwrap_or_default()
            .as_secs()
            - 3600, // 1 hour ago (expired)
    };

    client.set_access_token(expired_token)?;

    // Now try to get valid token - should trigger auto-refresh
    match client.get_valid_token().await {
        Ok(refreshed_token) => {
            println!("✓ Auto-refresh triggered successfully!");
            println!("  New Access Token: {}", refreshed_token.access_token);
            println!(
                "  Expires in: {} seconds",
                refreshed_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("Note: This may be due to invalid credentials");
        }
    }

    println!();
    println!("=== Refresh test completed ===");
    Ok(())
}

pub fn load_token_from_env(&self) -> NetDiskResult<()>

Examples found in repository

examples/user_info.rs (line 16)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    println!("=== Baidu NetDisk User Info Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .app_key("your_app_key")
        .app_secret("your_app_secret")
        .build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    println!("Getting user info...");
    let user_info = client.user().get_user_info(Some("v2")).await?;

    println!("\n=== User Information ===");
    println!("Baidu Name:    {}", user_info.baidu_name);
    println!("NetDisk Name:  {}", user_info.netdisk_name);
    println!("Avatar URL:    {}", user_info.avatar_url);
    println!(
        "VIP Type:      {}",
        match user_info.vip_type {
            0 => "Regular user",
            1 => "VIP member",
            2 => "SVIP super member",
            _ => "Unknown",
        }
    );
    println!("User ID (uk):  {}", user_info.uk);

    Ok(())
}

examples/category.rs (line 16)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let test_dir = "/apps/product";

    println!("=== Baidu NetDisk Category Test ===\n");

    println!("Testing directory: {}\n", test_dir);

    println!("=== Part 1: Global Category Counts (All files) ===");
    println!("----------------------------------------");
    test_global_counts(&client).await?;

    println!("\n\n=== Part 2: Category Counts in {} ===", test_dir);
    println!("----------------------------------------");
    test_directory_counts(&client, &test_dir).await?;

    println!("\n\n=== Part 3: List Files in Each Category ===");
    println!("----------------------------------------");
    test_list_category_files(&client, &test_dir).await?;

    println!("\n\n=== Category Test Completed ===");

    Ok(())
}

examples/upload_file.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk File Upload (Simple) ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_file(local_file, remote_path).await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_bytes.rs (line 11)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let remote_path = if args.len() >= 2 {
        &args[1]
    } else {
        "/upload/hello_bytes.txt"
    };

    println!("=== Baidu NetDisk Bytes Upload (Simple) ===");
    println!("Remote path: {}", remote_path);
    println!();

    let test_data = b"Hello from upload_bytes! This is a simple byte array upload test.";
    println!("Uploading {} bytes of data...", test_data.len());

    let start_time = std::time::Instant::now();

    let response = client.upload().upload_bytes(test_data, remote_path).await?;

    println!("Bytes uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_reader.rs (line 12)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    let local_file = if args.len() >= 2 {
        &args[1]
    } else {
        println!("Usage: {} <local_file> [remote_path]", args[0]);
        println!("Example: {} test.txt /upload/test.txt", args[0]);
        return Ok(());
    };

    let remote_path = if args.len() >= 3 {
        &args[2]
    } else {
        "/upload/test_reader.txt"
    };

    println!("=== Baidu NetDisk Reader Upload ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let file = std::fs::File::open(local_file)?;
    let metadata = file.metadata()?;
    let file_size = metadata.len();

    println!("File size: {} bytes", file_size);

    let mut reader = BufReader::new(file);

    let start_time = std::time::Instant::now();

    let response = client
        .upload()
        .upload_reader(&mut reader, file_size, remote_path)
        .await?;

    println!("File uploaded successfully!");
    println!("  FS ID: {}", response.fs_id);
    println!("  Server filename: {:?}", response.server_filename);
    println!("  Path: {}", response.path);
    println!("  Size: {} bytes", response.size);
    println!("  Category: {}", response.category);
    println!("  MD5: {}", response.md5.unwrap_or_default());
    println!("  Upload time: {:?}", start_time.elapsed());

    Ok(())
}

examples/upload_precreate.rs (line 49)

async fn main() -> Result<(), Box<dyn std::error::Error>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("info")).init();

    let client = BaiduNetDiskClient::builder().build()?;
    info!("Client created successfully");

    client.load_token_from_env()?;
    info!("Token loaded successfully");

    let args: Vec<String> = std::env::args().collect();

    if args.len() < 3 {
        println!("Usage: {} <local_file> <remote_path>", args[0]);
        println!("Example: {} test.txt /apps/test/test.txt", args[0]);
        return Ok(());
    }

    let local_file = &args[1];
    let remote_path = &args[2];

    println!("=== Baidu NetDisk Preupload Test ===");
    println!("Local file: {}", local_file);
    println!("Remote path: {}", remote_path);
    println!();

    let (file_size, block_list) = get_file_md5blocks(local_file, 4 * 1024 * 1024)?;
    let file_md5 = calculate_md5(local_file)?;

    println!("File size: {} bytes", file_size);
    println!("File MD5: {}", file_md5);
    println!("Block count: {}", block_list.len());
    println!("Block list: {:?}", block_list);
    println!();

    let options = PrecreateOptions::new(remote_path, file_size, block_list)
        .content_md5(&file_md5)
        .rtype(1);

    println!("Sending precreate request...");
    match client.upload().precreate(options).await {
        Ok(response) => {
            println!("Precreate success!");
            println!("  Upload ID: {}", response.uploadid);
            println!("  Path: {:?}", response.path);
            println!("  Return type: {}", response.return_type);
            println!("  Block list to upload: {:?}", response.block_list);
        }
        Err(e) => {
            println!("Precreate failed: {}", e);
        }
    }

    Ok(())
}

Additional examples can be found in:

• examples/upload_file_options.rs
• examples/quota.rs
• examples/list_all.rs
• examples/search.rs
• examples/token_test.rs
• examples/token_check.rs
• examples/token_refresh.rs
• examples/download.rs
• examples/category_list.rs
• examples/download_compare.rs
• examples/file.rs
• examples/playlist.rs

pub fn validate_token(&self) -> NetDiskResult<TokenStatus>

Examples found in repository

examples/token_test.rs (line 52)

async fn main() -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
    env_logger::Builder::from_env(env_logger::Env::default().default_filter_or("debug")).init();

    println!("=== Baidu NetDisk Token Test ===\n");

    let client = BaiduNetDiskClient::builder()
        .auto_refresh(true)
        .refresh_ahead_seconds(300)
        .build()?;

    println!("--- Part 1: Create AccessToken using builder ---");
    let token = AccessToken::new(
        "your_access_token".to_string(),
        "your_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
    );
    println!("✓ Created AccessToken");
    println!("  Valid for: {} seconds", token.remaining_seconds());

    println!("\n--- Part 2: Load Token from Environment ---");
    client.load_token_from_env()?;

    match client.get_valid_token().await {
        Ok(token) => {
            println!("✓ Token loaded from environment");
            println!("  Scope: {}", token.scope);
            println!("  Valid for: {} seconds", token.remaining_seconds());
        }
        Err(e) => {
            println!("✗ Failed to load token: {}", e);
            println!("\nSet these environment variables:");
            println!("  BD_NETDISK_ACCESS_TOKEN");
            println!("  BD_NETDISK_REFRESH_TOKEN");
            println!("  BD_NETDISK_EXPIRES_IN");
        }
    }

    println!("\n--- Part 3: Validate Token Status ---");
    match client.validate_token() {
        Ok(status) => match status {
            TokenStatus::Valid => println!("✓ Token is valid"),
            TokenStatus::ExpiringSoon => println!("⚠ Token is expiring soon (< 5 min)"),
            TokenStatus::Expired => println!("✗ Token is expired"),
        },
        Err(e) => println!("✗ No token set: {}", e),
    }

    println!("\n--- Part 4: Test Expired Token Auto-Refresh ---");
    let now = SystemTime::now()
        .duration_since(UNIX_EPOCH)
        .unwrap_or_default()
        .as_secs();

    let expired_token = AccessToken::with_all(
        "test_access_token".to_string(),
        "test_refresh_token".to_string(),
        2592000,
        "basic netdisk".to_string(),
        String::new(),
        String::new(),
        now - 2592000 - 3600,
    );

    println!("Created expired token:");
    println!("  Acquired: {} seconds ago", 2592000 + 3600);
    match expired_token.validate() {
        TokenStatus::Expired => println!("  Status: Expired ✓"),
        _ => println!("  Status: Unexpected"),
    }

    client.set_access_token(expired_token)?;

    println!("\nAttempting to get valid token (will try auto-refresh)...");
    match client.get_valid_token().await {
        Ok(new_token) => {
            println!("✓ Auto-refresh succeeded!");
            println!(
                "  New token valid for: {} seconds",
                new_token.remaining_seconds()
            );
        }
        Err(e) => {
            println!("✗ Auto-refresh failed: {}", e);
            println!("  → Need to re-authenticate via device code flow");
        }
    }

    println!("\n=== Test Complete ===");
    Ok(())
}

pub fn with_token(&self, token: AccessToken) -> TokenScopedClient

Trait Implementations

impl Clone for BaiduNetDiskClient

fn clone(&self) -> BaiduNetDiskClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BaiduNetDiskClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.