scm-sdk 0.1.1

Native async Strata Cloud Manager SDK, beginning with Prisma AIRS
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use super::{common, models::GatewayModelPricingConfig};
use crate::{Client, RawRequest, RequestOptions, Result, engine::AuthKind};
use std::time::Duration;

/// Public catalog policy. The caller supplies the endpoint/transport through a credential-free Client.
#[derive(Clone)]
#[non_exhaustive]
pub struct AIGatewayModelPricingClientOptions {
    pub timeout: Duration,
    pub read_retries: u32,
}
impl Default for AIGatewayModelPricingClientOptions {
    fn default() -> Self {
        Self {
            timeout: Duration::from_secs(60),
            read_retries: 0,
        }
    }
}
crate::redaction::redacted_debug!(AIGatewayModelPricingClientOptions);

/// Standalone public pricing; SCM and inference credentials are rejected.
#[derive(Clone, Debug)]
pub struct AIGatewayModelPricingClient {
    client: Client,
    defaults: AIGatewayModelPricingClientOptions,
}
impl AIGatewayModelPricingClient {
    pub fn new(client: Client) -> Result<Self> {
        client.require_auth(AuthKind::Public)?;
        Ok(Self {
            client,
            defaults: AIGatewayModelPricingClientOptions::default(),
        })
    }
    pub fn with_options(mut self, defaults: AIGatewayModelPricingClientOptions) -> Result<Self> {
        RequestOptions::with_timeout(defaults.timeout)?.with_retries(defaults.read_retries)?;
        self.defaults = defaults;
        Ok(self)
    }
    /// Return unevaluated, unconverted catalog data without any tenant billing claim.
    pub async fn get(
        &self,
        provider: &str,
        model: &str,
        options: Option<&RequestOptions>,
    ) -> Result<GatewayModelPricingConfig> {
        common::path_segment(provider)?;
        common::path_segment(model)?;
        let options = options
            .cloned()
            .map_or_else(|| RequestOptions::with_timeout(self.defaults.timeout), Ok)?;
        let options = if options.retry_limit().is_none() {
            options.with_retries(self.defaults.read_retries)?
        } else {
            options
        };
        self.client
            .send_contract(
                RawRequest::read("/model-configs/pricing")
                    .segment(provider)?
                    .segment(model)?
                    .header("accept", "application/json")?
                    .named("airs.gateway.model_pricing.get"),
                "GatewayModelPricingConfigSchema",
                Some(&options),
            )
            .await
    }
}