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,
}
#[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,
}
#[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?)
}
#[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>>,
}
#[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>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct DemographicSlice {
pub weight: f64,
pub demographic: DemographicQuery,
}
#[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>,
}
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?)
}