Struct Budget 

pub struct Budget {
    pub tokens: Option<u64>,
    pub usd: Option<Decimal>,
    pub wall: Option<Duration>,
    pub calls: Option<u32>,
}

What a node is permitted to spend, in whichever units were declared.

Any subset of the four may be set. A unit left as None is unbounded in that unit — it does not weaken the units that were declared.

Example

use boundgraph_core::Budget;
use std::time::Duration;

let b = Budget::UNBOUNDED
    .with_usd("0.50".parse().unwrap())
    .with_wall(Duration::from_secs(30));

assert!(!b.is_unbounded());
assert_eq!(b.tokens, None);      // tokens were never bounded
assert_eq!(b.declared_units(), ["usd", "wall"]);

Fields

tokens: Option<u64>

Total tokens, prompt plus completion.

usd: Option<Decimal>

Spend in US dollars.

A decimal, never a float: money that round-trips through f64 stops being auditable, and the ledger is meant to be audited.

wall: Option<Duration>

Wall-clock time.

calls: Option<u32>

Number of model calls.

Implementations

impl Budget

pub const UNBOUNDED: Self

No limit in any unit.

The default, and deliberately something you have to name — see the module documentation.

pub fn with_tokens(self, tokens: u64) -> Self

Bound the token count.

pub fn with_usd(self, usd: Decimal) -> Self

Bound the spend.

The amount is normalised, so 1.50 and 1.5 are the same budget and therefore encode to the same bytes and the same digest.

pub fn with_wall(self, wall: Duration) -> Self

Bound the wall-clock time.

pub fn with_calls(self, calls: u32) -> Self

Bound the number of model calls.

pub fn is_unbounded(&self) -> bool

Whether nothing at all is bounded.

pub fn amount(&self, unit: Unit) -> Option<u64>

What this budget bounds in one unit, normalised to an integer.

Currency becomes micro-dollars and time becomes milliseconds — see the module documentation for why there is one space to compare in. None means this budget does not bound that unit, which is not the same as bounding it at zero.

pub fn bounded_units(&self) -> Vec<Unit>

Which units this budget bounds, in a stable order.

pub fn excesses(&self, parent: &Self) -> Vec<Excess>

Every unit in which this budget asks for more than parent permits.

Only units both budgets bound can be exceeded — see the module documentation for why the two asymmetric cases are legal. Returns them all rather than the first, in unit order.

pub fn fits_within(&self, parent: &Self) -> bool

Whether this budget can be declared beneath parent.

True when it claims no more than the parent has to give, in every unit they both bound.

pub fn clamped_to(&self, parent: &Self) -> Self

This budget as it is actually enforced beneath parent.

The tighter of the two in every unit, which is the composition rule itself: an effective ceiling is the smallest bound on the path down to a node. Applying it to a budget that already fits_within its parent returns that budget with the parent’s bounds filled in where it declared none.

Idempotent, and associative down a chain: clamping to a parent and then to a grandparent gives what clamping straight to the tightest of the three would.

pub fn declared_units(&self) -> Vec<&'static str>

Which units this budget actually constrains, in a stable order.

Useful for diagnostics: “this flow bounds usd but not wall” is a reviewable statement.

Trait Implementations

impl Clone for Budget

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Budget

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

Formats the value using the given formatter.

impl Default for Budget

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Budget

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Budget

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

Formats the value using the given formatter.

impl Eq for Budget

impl Hash for Budget

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Budget

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Budget

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Budget

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Budget

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 Budget