Struct PmcClient 

pub struct PmcClient { /* private fields */ }

Client for interacting with PMC (PubMed Central) API

Implementations

impl PmcClient

pub fn new() -> Self

Create a new PMC client with default configuration

Uses default NCBI rate limiting (3 requests/second) and no API key. For production use, consider using with_config() to set an API key.

Example

use pubmed_client::PmcClient;

let client = PmcClient::new();

pub fn get_pmc_config(&self) -> &ClientConfig

pub fn get_tar_client_config(&self) -> &ClientConfig

pub fn with_config(config: ClientConfig) -> Self

Create a new PMC client with custom configuration

Arguments

• config - Client configuration including rate limits, API key, etc.

Example

use pubmed_client::{PmcClient, ClientConfig};

let config = ClientConfig::new()
    .with_api_key("your_api_key_here")
    .with_email("researcher@university.edu");

let client = PmcClient::with_config(config);

pub fn with_client(client: Client) -> Self

Create a new PMC client with custom HTTP client and default configuration

Arguments

• client - Custom reqwest client with specific configuration

Example

use pubmed_client::PmcClient;
use reqwest::Client;
use std::time::Duration;

let http_client = Client::builder()
    .timeout(Duration::from_secs(30))
    .build()
    .unwrap();

let client = PmcClient::with_client(http_client);

pub fn with_base_url(self, base_url: String) -> Self

Set a custom base URL for the PMC API

Arguments

• base_url - The base URL for the PMC API

pub async fn fetch_full_text(&self, pmcid: &str) -> Result<PmcArticle>

Fetch full text from PMC using PMCID

Arguments

• pmcid - PMC ID (with or without “PMC” prefix)

Returns

Returns a Result<PmcArticle> containing the structured full text

Errors

• ParseError::PmcNotAvailable - If PMC full text is not available
• PubMedError::RequestError - If the HTTP request fails
• ParseError::XmlError - If XML parsing fails

Example

use pubmed_client::PmcClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    let full_text = client.fetch_full_text("PMC7906746").await?;
    println!("Title: {}", full_text.title);
    println!("Sections: {}", full_text.sections.len());
    Ok(())
}

pub async fn fetch_xml(&self, pmcid: &str) -> Result<String>

Fetch raw XML content from PMC

Arguments

• pmcid - PMC ID (with or without “PMC” prefix)

Returns

Returns a Result<String> containing the raw XML content

pub async fn check_pmc_availability(&self, pmid: &str) -> Result<Option<String>>

Check if PMC full text is available for a given PMID

Arguments

• pmid - PubMed ID

Returns

Returns Result<Option<String>> containing the PMCID if available

Example

use pubmed_client::PmcClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    if let Some(pmcid) = client.check_pmc_availability("33515491").await? {
        println!("PMC available: {}", pmcid);
        let full_text = client.fetch_full_text(&pmcid).await?;
        println!("Title: {}", full_text.title);
    } else {
        println!("PMC not available");
    }
    Ok(())
}

pub async fn is_oa_subset(&self, pmcid: &str) -> Result<OaSubsetInfo>

Check if a PMC article is in the OA (Open Access) subset

The OA subset contains articles with programmatic access to full-text XML. Some publishers restrict programmatic access even though the article may be viewable on the PMC website.

Arguments

• pmcid - PMC ID (with or without “PMC” prefix)

Returns

Returns Result<OaSubsetInfo> containing detailed information about OA availability

Example

use pubmed_client::PmcClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    let oa_info = client.is_oa_subset("PMC7906746").await?;

    if oa_info.is_oa_subset {
        println!("Article is in OA subset");
        if let Some(link) = oa_info.download_link {
            println!("Download: {}", link);
        }
    } else {
        println!("Article is NOT in OA subset");
        if let Some(code) = oa_info.error_code {
            println!("Reason: {}", code);
        }
    }
    Ok(())
}

pub async fn download_and_extract_tar<P: AsRef<Path>>( &self, pmcid: &str, output_dir: P, ) -> Result<Vec<String>>

Download and extract tar.gz file for a PMC article using the OA API

Arguments

• pmcid - PMC ID (with or without “PMC” prefix)
• output_dir - Directory to extract the tar.gz contents to

Returns

Returns a Result<Vec<String>> containing the list of extracted file paths

Errors

• ParseError::InvalidPmid - If the PMCID format is invalid
• PubMedError::RequestError - If the HTTP request fails
• ParseError::IoError - If file operations fail
• ParseError::PmcNotAvailable - If the article is not available in OA

Example

use pubmed_client::PmcClient;
use std::path::Path;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    let output_dir = Path::new("./extracted_articles");
    let files = client.download_and_extract_tar("PMC7906746", output_dir).await?;

    for file in files {
        println!("Extracted: {}", file);
    }
    Ok(())
}

pub async fn extract_figures_with_captions<P: AsRef<Path>>( &self, pmcid: &str, output_dir: P, ) -> Result<Vec<ExtractedFigure>>

Download, extract tar.gz file, and match figures with their captions from XML

Arguments

• pmcid - PMC ID (with or without “PMC” prefix)
• output_dir - Directory to extract the tar.gz contents to

Returns

Returns a Result<Vec<ExtractedFigure>> containing figures with both XML metadata and file paths

Errors

• ParseError::InvalidPmid - If the PMCID format is invalid
• PubMedError::RequestError - If the HTTP request fails
• ParseError::IoError - If file operations fail
• ParseError::PmcNotAvailable - If the article is not available in OA

Example

use pubmed_client::PmcClient;
use std::path::Path;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    let output_dir = Path::new("./extracted_articles");
    let figures = client.extract_figures_with_captions("PMC7906746", output_dir).await?;

    for figure in figures {
        println!("Figure {}: {}", figure.figure.id, figure.figure.caption);
        println!("File: {}", figure.extracted_file_path);
    }
    Ok(())
}

pub async fn clear_cache(&self)

Clear all cached PMC data

Example

use pubmed_client::PmcClient;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let client = PmcClient::new();
    client.clear_cache().await;
    Ok(())
}

pub fn cache_entry_count(&self) -> u64

Get cache statistics

Returns the number of items in cache, or 0 if caching is disabled

Example

use pubmed_client::PmcClient;

let client = PmcClient::new();
let count = client.cache_entry_count();
println!("Cache entries: {}", count);

pub async fn sync_cache(&self)

Synchronize cache operations to ensure all pending operations are flushed

This is useful for testing to ensure cache statistics are accurate

Trait Implementations

impl Clone for PmcClient

fn clone(&self) -> PmcClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for PmcClient

fn default() -> Self

Returns the “default value” for a type.