Struct CodexRateLimit 

pub struct CodexRateLimit {
    pub allowed: bool,
    pub limit_reached: bool,
    pub primary_window: Option<CodexWindow>,
    pub secondary_window: Option<CodexWindow>,
}

Fields

allowed: bool

limit_reached: bool

primary_window: Option<CodexWindow>

secondary_window: Option<CodexWindow>

Implementations

impl CodexRateLimit

pub fn is_limited(&self) -> bool

Examples found in repository

examples/test_codex.rs (line 33)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
                let has_session = cookies
                    .iter()
                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));

                if !has_session {
                    continue;
                }

                println!(
                    "Using {} - {} ({} cookies)",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                );

                match seher::codex::CodexClient::fetch_usage(&cookies).await {
                    Ok(usage) => {
                        println!("\nSuccess! Codex usage:");
                        println!("  plan_type: {}", usage.plan_type);
                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
                        println!(
                            "  rate_limit reset_time: {:?}",
                            usage.rate_limit.next_reset_time()
                        );
                        println!(
                            "  code_review limited: {}",
                            usage
                                .code_review_rate_limit
                                .as_ref()
                                .is_some_and(seher::CodexRateLimit::is_limited)
                        );
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Codex usage: {e}");
                    }
                }
            }
        }
    }

    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
}

pub fn next_reset_time(&self) -> Option<DateTime<Utc>>

Examples found in repository

examples/test_codex.rs (line 36)

async fn main() {
    let detector = BrowserDetector::new();
    let browsers = detector.detect_browsers();

    for browser in &browsers {
        if !browser.is_chromium_based() {
            continue;
        }
        for prof in detector.list_profiles(*browser) {
            if let Ok(cookies) = CookieReader::read_cookies(&prof, "chatgpt.com") {
                let has_session = cookies
                    .iter()
                    .any(|c| c.name.starts_with("__Secure-next-auth.session-token"));

                if !has_session {
                    continue;
                }

                println!(
                    "Using {} - {} ({} cookies)",
                    browser.name(),
                    prof.name,
                    cookies.len(),
                );

                match seher::codex::CodexClient::fetch_usage(&cookies).await {
                    Ok(usage) => {
                        println!("\nSuccess! Codex usage:");
                        println!("  plan_type: {}", usage.plan_type);
                        println!("  rate_limit limited: {}", usage.rate_limit.is_limited());
                        println!(
                            "  rate_limit reset_time: {:?}",
                            usage.rate_limit.next_reset_time()
                        );
                        println!(
                            "  code_review limited: {}",
                            usage
                                .code_review_rate_limit
                                .as_ref()
                                .is_some_and(seher::CodexRateLimit::is_limited)
                        );
                        return;
                    }
                    Err(e) => {
                        println!("\nFailed to fetch Codex usage: {e}");
                    }
                }
            }
        }
    }

    println!("No chatgpt.com session with __Secure-next-auth.session-token found");
}

Trait Implementations

impl Clone for CodexRateLimit

fn clone(&self) -> CodexRateLimit

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CodexRateLimit

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CodexRateLimit

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for CodexRateLimit

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

where __S: Serializer,

Serialize this value into the given Serde serializer.