Struct Cost 

#[non_exhaustive]
pub struct Cost {
    pub input: Option<f64>,
    pub output: Option<f64>,
    pub cache_read: Option<f64>,
    pub cache_write: Option<f64>,
    pub total: f64,
    /* private fields */
}

What one or more turns cost, in USD. total is what was charged, or when Self::is_complete is false, a lower bound of it.

A part is None when its source does not give it: a provider that reports only a total leaves every part None, and one that reports input and output leaves the cache parts None. A cost computed from the catalog (Pricing::cost) leaves a cache part None when the catalog lists no rate for it and the usage has such tokens; its total then sums the known parts only, and it is not complete. A part is never filled with a placeholder 0.0. Summing costs keeps a part only when every side has it, and is complete only when every side is. A None part is left out when serialized, and an absent one reads back as None.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

input: Option<f64>

Uncached input tokens.

output: Option<f64>

Output tokens, reasoning included.

cache_read: Option<f64>

Input tokens read from a cache.

cache_write: Option<f64>

Input tokens written to a cache.

total: f64

The whole charge, or a lower bound of it when the cost is not complete.

Implementations

impl Cost

pub fn is_complete(&self) -> bool

Whether Self::total is the whole charge. false when a part the usage has tokens for had no known price, so total is a lower bound.

pub fn from_parts( input: f64, output: f64, cache_read: f64, cache_write: f64, ) -> Self

A cost split into its parts, each known; total is their sum.

pub fn from_total(total: f64) -> Self

A cost known only as its total; every part is None.

pub fn input(self, input: impl Into<Option<f64>>) -> Self

Set, or with None clear, Self::input. total is left as it is.

pub fn output(self, output: impl Into<Option<f64>>) -> Self

Set, or with None clear, Self::output. total is left as it is.

pub fn cache_read(self, cache_read: impl Into<Option<f64>>) -> Self

Set, or with None clear, Self::cache_read. total is left as it is.

pub fn cache_write(self, cache_write: impl Into<Option<f64>>) -> Self

Set, or with None clear, Self::cache_write. total is left as it is.

Trait Implementations

impl Add for Cost

total always sums. Each part sums only when both sides know it, and is None otherwise, so a summed part never understates what it covers. The sum is complete only when both sides are.

type Output = Cost

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self::Output

Performs the + operation.

impl Clone for Cost

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Cost

impl Debug for Cost

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

Formats the value using the given formatter.

impl Default for Cost

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Cost

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Cost

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for Cost

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Cost