fauna-api 1.0.859

The Fauna SDK for Rust: accounts, Drive, groups, calendar, chats, payments, Parrot and live rooms.
Documentation
use serde::{Deserialize, Serialize};
use serde_json::{Map, Value};

use crate::authentification::CredentialsOrApiKey;
use crate::error::Result;
use crate::groups::Group;
use crate::http::{client, encode, ok};

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Sex {
    Male,
    Female,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Race {
    White,
    Black,
    NativeAmerican,
    AlaskanNative,
    Hawaiian,
    Asian,
    PacificIslander,
    Hispanic,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Ethnicity {
    Italian,
    Irish,
    German,
    French,
    Spanish,
    Portuguese,
    Polish,
    Scottish,
    Norwegian,
    Danish,
    Swedish,
    Finnish,
    Icelandic,
    Dutch,
    Ukrainian,
    Mexican,
    Jewish,
    Korean,
    Chinese,
    Japanese,
    Filipino,
    Vietnamese,
    Indian,
    Tamil,
    Persian,
    Arab,
    Armenian,
    Russian,
    Greek,
    Brazilian,
    PuertoRican,
    Haitian,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Religion {
    Christian,
    Jewish,
    Muslim,
    Hindu,
    Buddhist,
    Sikh,
    Spiritual,
    Agnostic,
    Atheist,
    None,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum MaritalStatus {
    Married,
    Seperated,
    Divorced,
    Widowed,
    NeverMarried,
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
pub enum Education {
    Doctoral,
    Professional,
    Master,
    Bachelor,
    Associate,
    SomeCollege,
    HighSchool,
    None,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Demographic {
    pub age: f64,
    pub sex: Sex,
    pub race: Race,
    pub ethnicity: Vec<Ethnicity>,
    pub religion: Religion,
    pub birthplace: [f64; 2],
    pub location: [f64; 2],
    pub marital: MaritalStatus,
    pub education: Education,
    pub occupation: String,
    pub income: f64,
}

/// `Partial<Demographic>` in the TypeScript SDK.
#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct PartialDemographic {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub age: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sex: Option<Sex>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub race: Option<Race>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub ethnicity: Option<Vec<Ethnicity>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub religion: Option<Religion>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub birthplace: Option<[f64; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<[f64; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub marital: Option<MaritalStatus>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub education: Option<Education>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub occupation: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub income: Option<f64>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Identity {
    pub id: String,
    pub demographic: Demographic,
    pub background: String,
    pub dialect: String,
}

/// The `opts` argument of the persona calls: `group` reads that group's personas.
#[derive(Debug, Clone, Default)]
pub struct PersonaOptions {
    pub group: Option<Group>,
}

pub async fn all(authorization: &CredentialsOrApiKey, opts: PersonaOptions) -> Result<Vec<String>> {
    let mut request = client()
        .get(format!("{}/personas", super::get_url()))
        .header(
            "Authorization",
            match authorization {
                CredentialsOrApiKey::Credentials(credentials) => {
                    format!("Token {}", credentials.token)
                }
                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
            },
        );
    if let Some(group) = &opts.group {
        request = request.header("Group", &group.id);
    }
    Ok(request.send().await?.json().await?)
}

pub async fn get(
    authorization: &CredentialsOrApiKey,
    id: &str,
    opts: PersonaOptions,
) -> Result<Identity> {
    let mut request = client()
        .get(format!("{}/personas/{}", super::get_url(), encode(id)))
        .header(
            "Authorization",
            match authorization {
                CredentialsOrApiKey::Credentials(credentials) => {
                    format!("Token {}", credentials.token)
                }
                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
            },
        );
    if let Some(group) = &opts.group {
        request = request.header("Group", &group.id);
    }
    Ok(request.send().await?.json().await?)
}

/// `Race | Race[]` in the TypeScript SDK.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RaceOrRaces {
    Race(Race),
    Races(Vec<Race>),
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DemographicQuery {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub age: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sex: Option<Sex>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub race: Option<RaceOrRaces>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub location: Option<[f64; 2]>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub occupation: Option<String>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub income: Option<f64>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub interests: Option<Vec<String>>,
}

/// `{ min, max }` in the TypeScript SDK.
#[derive(Debug, Clone, Copy, PartialEq, Serialize, Deserialize)]
pub struct DemographicRange {
    pub min: f64,
    pub max: f64,
}

#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
pub struct DemographicFilters {
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub sex: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub race: Option<Vec<String>>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub age: Option<DemographicRange>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub income: Option<DemographicRange>,
    #[serde(default, skip_serializing_if = "Option::is_none")]
    pub occupation: Option<String>,
}

/// One weighted slice of a seed query.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DemographicSlice {
    pub weight: f64,
    pub demographic: DemographicQuery,
}

/// The `opts` argument of `query_personas`.
#[derive(Debug, Clone, Default)]
pub struct PersonaQuery {
    pub cursor: u32,
    pub max: u32,
    pub filters: Option<DemographicFilters>,
    pub slices: Option<Vec<DemographicSlice>>,
    pub group: Option<Group>,
}

/// Catalog browse (filters plus cursor and max) or weighted seed (slices, where max is the sample size).
pub async fn query_personas(
    authorization: &CredentialsOrApiKey,
    opts: PersonaQuery,
) -> Result<Vec<Identity>> {
    let mut request = client()
        .post(format!("{}/persona/query", super::get_url()))
        .header(
            "Authorization",
            match authorization {
                CredentialsOrApiKey::Credentials(credentials) => {
                    format!("Token {}", credentials.token)
                }
                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
            },
        );
    if let Some(group) = &opts.group {
        request = request.header("Group", &group.id);
    }
    let mut body = Map::new();
    body.insert("cursor".to_string(), Value::from(opts.cursor));
    body.insert("max".to_string(), Value::from(opts.max));
    if let Some(filters) = &opts.filters {
        body.insert("filters".to_string(), serde_json::to_value(filters)?);
    }
    if let Some(slices) = &opts.slices {
        body.insert("slices".to_string(), serde_json::to_value(slices)?);
    }
    let response = request.json(&body).send().await?;
    Ok(ok(response).await?.json().await?)
}

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum PriorReason {
    Hnsw,
    Occupation,
    Demo,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct PriorEdge {
    pub to: String,
    pub weight: f64,
    pub reasons: Vec<PriorReason>,
}

#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Prior {
    pub embedder: String,
    pub k: u32,
    pub edges: Vec<PriorEdge>,
}

pub async fn prior(
    authorization: &CredentialsOrApiKey,
    id: &str,
    opts: PersonaOptions,
) -> Result<Prior> {
    let mut request = client()
        .get(format!("{}/persona/prior/{}", super::get_url(), encode(id)))
        .header(
            "Authorization",
            match authorization {
                CredentialsOrApiKey::Credentials(credentials) => {
                    format!("Token {}", credentials.token)
                }
                CredentialsOrApiKey::ApiKey(key) => format!("ApiKey {}", key.id),
            },
        );
    if let Some(group) = &opts.group {
        request = request.header("Group", &group.id);
    }
    let response = request.send().await?;
    Ok(ok(response).await?.json().await?)
}