(Feat): Initial Commit

.gitignore

@@ -0,0 +1,21 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+discord_bot/.venv
+discord_bot/config/config.toml
+discord_bot/logs/
+backend_api/target/
+backend_api/logs/
+backend_api/data/
+backend_api/src/config/config.toml
+
+.vscode
+.qodo
+.target
+things-todo.md

backend_api/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "backend_api"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+poem = "3.1.12"
+poem-openapi = { version = "5.1.16", features = ["swagger-ui"] }
+tokio = { version = "1.48.0", features = ["full"] }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"
+reqwest = { version = "0.11", default-features = false, features = ["json", "rustls-tls", "multipart"] }
+sha2 = "0.10"
+hex = "0.4"
+chrono = { version = "0.4", features = ["serde"] }
+toml = "0.8"
+anyhow = "1.0"
+thiserror = "1.0"
+tracing = "0.1"
+tracing-subscriber = { version = "0.3", features = ["env-filter"] }
+image = "0.25"
+base64 = "0.22"
+tesseract = { version = "0.14", optional = true }
+validator = { version = "0.18", features = ["derive"] }
+strum = { version = "0.26", features = ["derive"] }
+sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "sqlite", "postgres", "chrono"] }
+
+[features]
+default = []
+ocr = ["tesseract"]

backend_api/src/cache.rs

@@ -0,0 +1,170 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use chrono::{DateTime, Utc, Duration};
+use crate::models::CacheEntry;
+
+#[derive(Clone)]
+pub struct CacheItem {
+    pub entry: CacheEntry,
+    pub expires_at: DateTime<Utc>,
+}
+
+pub struct Cache {
+    store: Arc<RwLock<HashMap<String, CacheItem>>>,
+    ttl_seconds: i64,
+    max_size: usize,
+    hits: Arc<RwLock<u64>>,
+    misses: Arc<RwLock<u64>>,
+}
+
+impl Cache {
+    pub fn new(ttl_seconds: i64, max_size: usize) -> Self {
+        Self {
+            store: Arc::new(RwLock::new(HashMap::new())),
+            ttl_seconds,
+            max_size,
+            hits: Arc::new(RwLock::new(0)),
+            misses: Arc::new(RwLock::new(0)),
+        }
+    }
+
+    pub async fn get(&self, checksum: &str) -> Option<CacheEntry> {
+        let mut store = self.store.write().await;
+        
+        if let Some(item) = store.get_mut(checksum) {
+            // Check if expired
+            if Utc::now() > item.expires_at {
+                store.remove(checksum);
+                let mut misses = self.misses.write().await;
+                *misses += 1;
+                return None;
+            }
+            
+            // Update access count and last accessed
+            item.entry.access_count += 1;
+            item.entry.last_accessed = Utc::now().to_rfc3339();
+            
+            let mut hits = self.hits.write().await;
+            *hits += 1;
+            
+            return Some(item.entry.clone());
+        }
+        
+        let mut misses = self.misses.write().await;
+        *misses += 1;
+        None
+    }
+
+    pub async fn insert(&self, checksum: String, entry: CacheEntry) {
+        let mut store = self.store.write().await;
+        
+        // If cache is full, remove oldest entry
+        if store.len() >= self.max_size {
+            if let Some(oldest_key) = store
+                .iter()
+                .min_by_key(|(_, item)| &item.entry.created_at)
+                .map(|(k, _)| k.clone())
+            {
+                store.remove(&oldest_key);
+            }
+        }
+        
+        let expires_at = Utc::now() + Duration::seconds(self.ttl_seconds);
+        store.insert(checksum, CacheItem { entry, expires_at });
+    }
+
+    pub async fn get_all(&self, limit: Option<usize>, offset: Option<usize>) -> Vec<CacheEntry> {
+        let store = self.store.read().await;
+        let now = Utc::now();
+        
+        let mut entries: Vec<CacheEntry> = store
+            .values()
+            .filter(|item| now <= item.expires_at)
+            .map(|item| item.entry.clone())
+            .collect();
+        
+        // Sort by created_at descending
+        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        
+        let offset = offset.unwrap_or(0);
+        let limit = limit.unwrap_or(entries.len());
+        
+        entries.into_iter().skip(offset).take(limit).collect()
+    }
+
+    pub async fn get_by_guild(&self, guild_id: &str) -> Vec<CacheEntry> {
+        let store = self.store.read().await;
+        let now = Utc::now();
+        
+        let mut entries: Vec<CacheEntry> = store
+            .values()
+            .filter(|item| now <= item.expires_at && item.entry.guild_id == guild_id)
+            .map(|item| item.entry.clone())
+            .collect();
+        
+        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        entries
+    }
+
+    pub async fn get_by_user(&self, user_id: &str) -> Vec<CacheEntry> {
+        let store = self.store.read().await;
+        let now = Utc::now();
+        
+        let mut entries: Vec<CacheEntry> = store
+            .values()
+            .filter(|item| now <= item.expires_at && item.entry.user_id == user_id)
+            .map(|item| item.entry.clone())
+            .collect();
+        
+        entries.sort_by(|a, b| b.created_at.cmp(&a.created_at));
+        entries
+    }
+
+    pub async fn delete_by_id(&self, id: i64) -> u64 {
+        let mut store = self.store.write().await;
+        let initial_len = store.len();
+        
+        store.retain(|_, item| item.entry.id != id);
+        
+        (initial_len - store.len()) as u64
+    }
+
+    pub async fn delete_by_guild(&self, guild_id: &str) -> u64 {
+        let mut store = self.store.write().await;
+        let initial_len = store.len();
+        
+        store.retain(|_, item| item.entry.guild_id != guild_id);
+        
+        (initial_len - store.len()) as u64
+    }
+
+    pub async fn delete_by_user(&self, user_id: &str) -> u64 {
+        let mut store = self.store.write().await;
+        let initial_len = store.len();
+        
+        store.retain(|_, item| item.entry.user_id != user_id);
+        
+        (initial_len - store.len()) as u64
+    }
+
+    pub async fn delete_all(&self) -> u64 {
+        let mut store = self.store.write().await;
+        let count = store.len() as u64;
+        store.clear();
+        count
+    }
+
+    pub async fn get_stats(&self) -> (u64, u64, usize) {
+        let hits = *self.hits.read().await;
+        let misses = *self.misses.read().await;
+        let size = self.store.read().await.len();
+        (hits, misses, size)
+    }
+
+    pub async fn cleanup_expired(&self) {
+        let mut store = self.store.write().await;
+        let now = Utc::now();
+        store.retain(|_, item| now <= item.expires_at);
+    }
+}

backend_api/src/checksum.rs

@@ -0,0 +1,33 @@
+use sha2::{Sha256, Digest};
+use crate::models::SummarizeRequest;
+
+pub fn calculate_checksum(request: &SummarizeRequest) -> String {
+    let mut hasher = Sha256::new();
+    
+    // Include all relevant fields in the checksum
+    hasher.update(request.text.as_bytes());
+    hasher.update(format!("{:?}", request.provider).as_bytes());
+    
+    if let Some(model) = &request.model {
+        hasher.update(model.as_bytes());
+    }
+    
+    if let Some(temp) = request.temperature {
+        hasher.update(temp.to_string().as_bytes());
+    }
+    
+    if let Some(max_tokens) = request.max_tokens {
+        hasher.update(max_tokens.to_string().as_bytes());
+    }
+    
+    if let Some(top_p) = request.top_p {
+        hasher.update(top_p.to_string().as_bytes());
+    }
+    
+    if let Some(system_prompt) = &request.system_prompt {
+        hasher.update(system_prompt.as_bytes());
+    }
+    
+    let result = hasher.finalize();
+    hex::encode(result)
+}

backend_api/src/claude_models.rs

@@ -0,0 +1,153 @@
+use serde::{Deserialize, Serialize};
+use std::fmt;
+
+/// Claude model configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ClaudeModel {
+    /// Model identifier used in API calls
+    pub id: String,
+    /// Human-readable model name
+    pub name: String,
+    /// Input token cost per million tokens (USD)
+    pub input_price_per_million: f64,
+    /// Output token cost per million tokens (USD)
+    pub output_price_per_million: f64,
+    /// Maximum context window size
+    pub max_context_tokens: u32,
+    /// Whether this model is currently available
+    pub available: bool,
+}
+
+/// Enum of available Claude models
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub enum ClaudeModelType {
+    /// Claude Sonnet 4.5 (2025-09-29) - Balanced performance and cost
+    Sonnet4_5,
+    /// Claude Haiku 4.5 (2025-10-01) - Fast and cost-effective
+    Haiku4_5,
+    /// Claude Opus 4.5 (2025-10-01) - Most capable, highest cost
+    Opus4_5,
+    /// Claude Sonnet 3.7 (2025-02-19) - Previous generation balanced model
+    Sonnet3_7,
+    /// Custom model (for flexibility)
+    Custom(String),
+}
+
+impl ClaudeModelType {
+    /// Get the model ID string for API calls
+    pub fn id(&self) -> String {
+        match self {
+            ClaudeModelType::Sonnet4_5 => "claude-sonnet-4-5-20250929".to_string(),
+            ClaudeModelType::Haiku4_5 => "claude-haiku-4-5-20251001".to_string(),
+            ClaudeModelType::Opus4_5 => "claude-opus-4-5-20251001".to_string(),
+            ClaudeModelType::Sonnet3_7 => "claude-3-7-sonnet-20250219".to_string(),
+            ClaudeModelType::Custom(id) => id.clone(),
+        }
+    }
+
+    /// Get full model information including pricing
+    pub fn info(&self) -> ClaudeModel {
+        match self {
+            ClaudeModelType::Sonnet4_5 => ClaudeModel {
+                id: self.id(),
+                name: "Claude Sonnet 4.5".to_string(),
+                input_price_per_million: 3.0,
+                output_price_per_million: 15.0,
+                max_context_tokens: 200_000,
+                available: true,
+            },
+            ClaudeModelType::Haiku4_5 => ClaudeModel {
+                id: self.id(),
+                name: "Claude Haiku 4.5".to_string(),
+                input_price_per_million: 0.8,
+                output_price_per_million: 4.0,
+                max_context_tokens: 200_000,
+                available: true,
+            },
+            ClaudeModelType::Opus4_5 => ClaudeModel {
+                id: self.id(),
+                name: "Claude Opus 4.5".to_string(),
+                input_price_per_million: 15.0,
+                output_price_per_million: 75.0,
+                max_context_tokens: 200_000,
+                available: true,
+            },
+            ClaudeModelType::Sonnet3_7 => ClaudeModel {
+                id: self.id(),
+                name: "Claude 3.7 Sonnet".to_string(),
+                input_price_per_million: 3.0,
+                output_price_per_million: 15.0,
+                max_context_tokens: 200_000,
+                available: true,
+            },
+            ClaudeModelType::Custom(id) => ClaudeModel {
+                id: id.clone(),
+                name: format!("Custom Model: {}", id),
+                input_price_per_million: 3.0, // Default to Sonnet pricing
+                output_price_per_million: 15.0,
+                max_context_tokens: 200_000,
+                available: true,
+            },
+        }
+    }
+
+    /// Parse a model ID string into a ClaudeModelType
+    pub fn from_id(id: &str) -> Self {
+        match id {
+            "claude-sonnet-4-5-20250929" => ClaudeModelType::Sonnet4_5,
+            "claude-haiku-4-5-20251001" => ClaudeModelType::Haiku4_5,
+            "claude-opus-4-5-20251001" => ClaudeModelType::Opus4_5,
+            "claude-3-7-sonnet-20250219" => ClaudeModelType::Sonnet3_7,
+            _ => ClaudeModelType::Custom(id.to_string()),
+        }
+    }
+
+    /// Get a list of all available Claude models
+    pub fn all_available() -> Vec<ClaudeModelType> {
+        vec![
+            ClaudeModelType::Sonnet4_5,
+            ClaudeModelType::Haiku4_5,
+            ClaudeModelType::Opus4_5,
+            ClaudeModelType::Sonnet3_7,
+        ]
+    }
+
+    /// Calculate cost for token usage
+    pub fn calculate_cost(&self, input_tokens: u32, output_tokens: u32) -> f64 {
+        let info = self.info();
+        let input_cost = (input_tokens as f64 / 1_000_000.0) * info.input_price_per_million;
+        let output_cost = (output_tokens as f64 / 1_000_000.0) * info.output_price_per_million;
+        input_cost + output_cost
+    }
+}
+
+impl fmt::Display for ClaudeModelType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.id())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_model_id() {
+        assert_eq!(ClaudeModelType::Sonnet4_5.id(), "claude-sonnet-4-5-20250929");
+        assert_eq!(ClaudeModelType::Haiku4_5.id(), "claude-haiku-4-5-20251001");
+    }
+
+    #[test]
+    fn test_from_id() {
+        assert_eq!(
+            ClaudeModelType::from_id("claude-sonnet-4-5-20250929"),
+            ClaudeModelType::Sonnet4_5
+        );
+    }
+
+    #[test]
+    fn test_cost_calculation() {
+        let cost = ClaudeModelType::Sonnet4_5.calculate_cost(1_000_000, 1_000_000);
+        assert_eq!(cost, 18.0); // 3.0 + 15.0
+    }
+}

backend_api/src/config.rs

@@ -0,0 +1,103 @@
+use serde::{Deserialize, Serialize};
+use std::fs;
+use anyhow::Result;
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Config {
+    pub server: ServerConfig,
+    pub database: DatabaseConfig,
+    pub anthropic: Option<AnthropicConfig>,
+    pub ollama: Option<OllamaConfig>,
+    pub lmstudio: Option<LmStudioConfig>,
+    pub rate_limiting: RateLimitingConfig,
+    pub cache: CacheConfig,
+    pub credits: CreditsConfig,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CreditsConfig {
+    /// Whether the credit system is enabled
+    pub enabled: bool,
+    /// User IDs that bypass the credit system (bot owners)
+    #[serde(default)]
+    pub bypass_user_ids: Vec<String>,
+    /// Credits cost per summarization
+    #[serde(default = "default_credits_per_summary")]
+    pub credits_per_summary: i64,
+    /// Credits cost per OCR summarization
+    #[serde(default = "default_credits_per_ocr")]
+    pub credits_per_ocr: i64,
+}
+
+fn default_credits_per_summary() -> i64 { 1 }
+fn default_credits_per_ocr() -> i64 { 2 }
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct ServerConfig {
+    pub host: String,
+    pub port: u16,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[serde(rename_all = "lowercase")]
+pub enum DatabaseType {
+    Sqlite,
+    Postgres,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct DatabaseConfig {
+    #[serde(rename = "type")]
+    pub db_type: DatabaseType,
+    pub url: String,
+}
+
+
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct AnthropicConfig {
+    pub api_key: String,
+    pub base_url: String,
+    pub model: String,
+    pub max_tokens: u32,
+    pub temperature: f32,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct OllamaConfig {
+    pub base_url: String,
+    pub model: String,
+    pub temperature: f32,
+    pub max_tokens: u32,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct LmStudioConfig {
+    pub base_url: String,
+    pub model: String,
+    pub temperature: f32,
+    pub max_tokens: u32,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct RateLimitingConfig {
+    pub enabled: bool,
+    pub guild_rate_limit: u32,
+    pub user_rate_limit: u32,
+    pub window_seconds: Option<i64>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct CacheConfig {
+    pub enabled: bool,
+    pub ttl_seconds: Option<i64>,
+    pub max_size: Option<usize>,
+}
+
+impl Config {
+    pub fn load(path: &str) -> Result<Self> {
+        let content = fs::read_to_string(path)?;
+        let config: Config = toml::from_str(&content)?;
+        Ok(config)
+    }
+}

backend_api/src/config/config.toml.example

@@ -0,0 +1,46 @@
+[server]
+host = "127.0.0.1"
+port = 3001
+
+[anthropic]
+api_key = "your-anthropic-api-key-here"
+base_url = "https://api.anthropic.com/v1"
+model = "claude-3-5-sonnet-20241022"
+max_tokens = 4096
+temperature = 1.0
+
+[ollama]
+base_url = "http://localhost:11434"
+model = "llama3.2"
+temperature = 0.7
+max_tokens = 4096
+
+[rate_limiting]
+enabled = true
+# Requests per minute per guild
+guild_rate_limit = 30
+# Requests per minute per user
+user_rate_limit = 10
+# Rate limit window in seconds (default: 60)
+window_seconds = 60
+
+[cache]
+enabled = true
+# Cache TTL in seconds (default: 3600 = 1 hour)
+ttl_seconds = 3600
+# Maximum number of cache entries (default: 1000)
+max_size = 1000
+
+[credits]
+# Enable credit-based monetization
+enabled = true
+# User IDs that bypass the credit system (bot owners)
+bypass_user_ids = ["YOUR_DISCORD_USER_ID_HERE"]
+# Credits cost per summarization (default: 1)
+credits_per_summary = 1
+# Credits cost per OCR summarization (default: 2)
+credits_per_ocr = 2
+
+[database]
+type = "sqlite"
+url = "sqlite:summarizer.db"

backend_api/src/credits.rs

@@ -0,0 +1,621 @@
+//! Credit system for monetization
+//!
+//! Handles user credits, tiers, transactions, and bypass functionality.
+
+use anyhow::Result;
+use chrono::Utc;
+use serde::{Deserialize, Serialize};
+use sqlx::Row;
+use tracing::{debug, info};
+
+use crate::database::DatabasePool;
+
+/// User tier levels
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "lowercase")]
+#[allow(dead_code)]
+pub enum TierLevel {
+    Free = 1,
+    Basic = 2,
+    Pro = 3,
+    Unlimited = 4,
+}
+
+#[allow(dead_code)]
+impl TierLevel {
+    pub fn from_id(id: i32) -> Self {
+        match id {
+            1 => TierLevel::Free,
+            2 => TierLevel::Basic,
+            3 => TierLevel::Pro,
+            4 => TierLevel::Unlimited,
+            _ => TierLevel::Free,
+        }
+    }
+
+    pub fn name(&self) -> &'static str {
+        match self {
+            TierLevel::Free => "Free",
+            TierLevel::Basic => "Basic",
+            TierLevel::Pro => "Pro",
+            TierLevel::Unlimited => "Unlimited",
+        }
+    }
+
+    pub fn monthly_credits(&self) -> i64 {
+        match self {
+            TierLevel::Free => 50,
+            TierLevel::Basic => 500,
+            TierLevel::Pro => 2000,
+            TierLevel::Unlimited => -1, // Unlimited
+        }
+    }
+
+    pub fn max_messages(&self) -> i32 {
+        match self {
+            TierLevel::Free => 50,
+            TierLevel::Basic => 100,
+            TierLevel::Pro => 250,
+            TierLevel::Unlimited => 500,
+        }
+    }
+
+    pub fn price_usd(&self) -> f64 {
+        match self {
+            TierLevel::Free => 0.0,
+            TierLevel::Basic => 4.99,
+            TierLevel::Pro => 9.99,
+            TierLevel::Unlimited => 19.99,
+        }
+    }
+}
+
+/// User credit information
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct UserCredits {
+    pub user_id: String,
+    pub credits: i64,
+    pub tier_id: i32,
+    pub lifetime_credits_used: i64,
+    pub created_at: String,
+    pub updated_at: String,
+}
+
+impl UserCredits {
+    pub fn tier(&self) -> TierLevel {
+        TierLevel::from_id(self.tier_id)
+    }
+
+    pub fn has_unlimited(&self) -> bool {
+        self.tier() == TierLevel::Unlimited
+    }
+}
+
+/// Credit transaction record
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[allow(dead_code)]
+pub struct CreditTransaction {
+    pub id: i64,
+    pub user_id: String,
+    pub guild_id: Option<String>,
+    pub amount: i64,
+    pub transaction_type: String,
+    pub description: String,
+    pub balance_after: i64,
+    pub created_at: String,
+}
+
+/// Result of a credit check
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CreditCheckResult {
+    pub allowed: bool,
+    pub reason: Option<String>,
+    pub credits_remaining: i64,
+    pub is_bypass: bool,
+    pub tier: String,
+}
+
+/// Credit system manager
+pub struct CreditSystem {
+    bypass_user_ids: Vec<String>,
+}
+
+#[allow(dead_code)]
+impl CreditSystem {
+    pub fn new(bypass_user_ids: Vec<String>) -> Self {
+        info!("Credit system initialized with {} bypass users", bypass_user_ids.len());
+        Self { bypass_user_ids }
+    }
+
+    /// Check if a user can bypass the credit system
+    pub fn is_bypass_user(&self, user_id: &str) -> bool {
+        self.bypass_user_ids.contains(&user_id.to_string())
+    }
+
+    /// Check if user has sufficient credits
+    pub async fn check_credits(
+        &self,
+        pool: &DatabasePool,
+        user_id: &str,
+        credits_needed: i64,
+    ) -> Result<CreditCheckResult> {
+        // Check bypass first
+        if self.is_bypass_user(user_id) {
+            debug!("User {} is a bypass user, allowing request", user_id);
+            return Ok(CreditCheckResult {
+                allowed: true,
+                reason: None,
+                credits_remaining: -1,
+                is_bypass: true,
+                tier: "Bypass".to_string(),
+            });
+        }
+
+        // Get or create user credits
+        let user_credits = self.get_or_create_user(pool, user_id).await?;
+
+        // Unlimited tier users always pass
+        if user_credits.has_unlimited() {
+            return Ok(CreditCheckResult {
+                allowed: true,
+                reason: None,
+                credits_remaining: -1,
+                is_bypass: false,
+                tier: user_credits.tier().name().to_string(),
+            });
+        }
+
+        // Check if user has enough credits
+        if user_credits.credits >= credits_needed {
+            Ok(CreditCheckResult {
+                allowed: true,
+                reason: None,
+                credits_remaining: user_credits.credits,
+                is_bypass: false,
+                tier: user_credits.tier().name().to_string(),
+            })
+        } else {
+            Ok(CreditCheckResult {
+                allowed: false,
+                reason: Some(format!(
+                    "Insufficient credits. You have {} but need {}",
+                    user_credits.credits, credits_needed
+                )),
+                credits_remaining: user_credits.credits,
+                is_bypass: false,
+                tier: user_credits.tier().name().to_string(),
+            })
+        }
+    }
+
+    /// Deduct credits from a user
+    pub async fn deduct_credits(
+        &self,
+        pool: &DatabasePool,
+        user_id: &str,
+        amount: i64,
+        guild_id: Option<&str>,
+        description: &str,
+    ) -> Result<i64> {
+        // Bypass users don't get charged
+        if self.is_bypass_user(user_id) {
+            debug!("Bypass user {}, not deducting credits", user_id);
+            return Ok(-1);
+        }
+
+        let user_credits = self.get_or_create_user(pool, user_id).await?;
+
+        // Unlimited tier users don't get charged
+        if user_credits.has_unlimited() {
+            debug!("Unlimited tier user {}, not deducting credits", user_id);
+            return Ok(-1);
+        }
+
+        let new_balance = (user_credits.credits - amount).max(0);
+        let now = Utc::now().to_rfc3339();
+
+        match pool {
+            DatabasePool::Sqlite(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET credits = ?, lifetime_credits_used = lifetime_credits_used + ?, updated_at = ? WHERE user_id = ?"
+                )
+                .bind(new_balance)
+                .bind(amount)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+
+                // Record transaction
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+                )
+                .bind(user_id)
+                .bind(guild_id)
+                .bind(-amount)
+                .bind("usage")
+                .bind(description)
+                .bind(new_balance)
+                .bind(&now)
+                .execute(p)
+                .await?;
+            }
+            DatabasePool::Postgres(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET credits = $1, lifetime_credits_used = lifetime_credits_used + $2, updated_at = $3 WHERE user_id = $4"
+                )
+                .bind(new_balance)
+                .bind(amount)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7)"
+                )
+                .bind(user_id)
+                .bind(guild_id)
+                .bind(-amount)
+                .bind("usage")
+                .bind(description)
+                .bind(new_balance)
+                .bind(&now)
+                .execute(p)
+                .await?;
+            }
+        }
+
+        debug!("Deducted {} credits from user {}, new balance: {}", amount, user_id, new_balance);
+        Ok(new_balance)
+    }
+
+    /// Add credits to a user (for refunds, purchases, etc.)
+    pub async fn add_credits(
+        &self,
+        pool: &DatabasePool,
+        user_id: &str,
+        amount: i64,
+        guild_id: Option<&str>,
+        transaction_type: &str,
+        description: &str,
+    ) -> Result<i64> {
+        let user_credits = self.get_or_create_user(pool, user_id).await?;
+        let new_balance = user_credits.credits + amount;
+        let now = Utc::now().to_rfc3339();
+
+        match pool {
+            DatabasePool::Sqlite(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET credits = ?, updated_at = ? WHERE user_id = ?"
+                )
+                .bind(new_balance)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES (?, ?, ?, ?, ?, ?, ?)"
+                )
+                .bind(user_id)
+                .bind(guild_id)
+                .bind(amount)
+                .bind(transaction_type)
+                .bind(description)
+                .bind(new_balance)
+                .bind(&now)
+                .execute(p)
+                .await?;
+            }
+            DatabasePool::Postgres(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET credits = $1, updated_at = $2 WHERE user_id = $3"
+                )
+                .bind(new_balance)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES ($1, $2, $3, $4, $5, $6, $7)"
+                )
+                .bind(user_id)
+                .bind(guild_id)
+                .bind(amount)
+                .bind(transaction_type)
+                .bind(description)
+                .bind(new_balance)
+                .bind(&now)
+                .execute(p)
+                .await?;
+            }
+        }
+
+        info!("Added {} credits to user {}, new balance: {}", amount, user_id, new_balance);
+        Ok(new_balance)
+    }
+
+    /// Get or create user credits
+    pub async fn get_or_create_user(&self, pool: &DatabasePool, user_id: &str) -> Result<UserCredits> {
+        let now = Utc::now().to_rfc3339();
+        let default_credits = TierLevel::Free.monthly_credits();
+
+        match pool {
+            DatabasePool::Sqlite(p) => {
+                // Try to get existing user
+                let row = sqlx::query(
+                    "SELECT user_id, credits, tier_id, lifetime_credits_used, created_at, updated_at FROM user_credits WHERE user_id = ?"
+                )
+                .bind(user_id)
+                .fetch_optional(p)
+                .await?;
+
+                if let Some(r) = row {
+                    return Ok(UserCredits {
+                        user_id: r.get(0),
+                        credits: r.get(1),
+                        tier_id: r.get(2),
+                        lifetime_credits_used: r.get(3),
+                        created_at: r.get(4),
+                        updated_at: r.get(5),
+                    });
+                }
+
+                // Create new user
+                sqlx::query(
+                    "INSERT INTO user_credits (user_id, credits, tier_id, lifetime_credits_used, created_at, updated_at) VALUES (?, ?, 1, 0, ?, ?)"
+                )
+                .bind(user_id)
+                .bind(default_credits)
+                .bind(&now)
+                .bind(&now)
+                .execute(p)
+                .await?;
+
+                // Record initial grant
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES (?, NULL, ?, ?, ?, ?, ?)"
+                )
+                .bind(user_id)
+                .bind(default_credits)
+                .bind("grant")
+                .bind("Initial free tier credits")
+                .bind(default_credits)
+                .bind(&now)
+                .execute(p)
+                .await?;
+
+                Ok(UserCredits {
+                    user_id: user_id.to_string(),
+                    credits: default_credits,
+                    tier_id: 1,
+                    lifetime_credits_used: 0,
+                    created_at: now.clone(),
+                    updated_at: now,
+                })
+            }
+            DatabasePool::Postgres(p) => {
+                let row = sqlx::query(
+                    "SELECT user_id, credits, tier_id, lifetime_credits_used, created_at, updated_at FROM user_credits WHERE user_id = $1"
+                )
+                .bind(user_id)
+                .fetch_optional(p)
+                .await?;
+
+                if let Some(r) = row {
+                    return Ok(UserCredits {
+                        user_id: r.get(0),
+                        credits: r.get(1),
+                        tier_id: r.get(2),
+                        lifetime_credits_used: r.get(3),
+                        created_at: r.get(4),
+                        updated_at: r.get(5),
+                    });
+                }
+
+                sqlx::query(
+                    "INSERT INTO user_credits (user_id, credits, tier_id, lifetime_credits_used, created_at, updated_at) VALUES ($1, $2, 1, 0, $3, $4)"
+                )
+                .bind(user_id)
+                .bind(default_credits)
+                .bind(&now)
+                .bind(&now)
+                .execute(p)
+                .await?;
+
+                sqlx::query(
+                    "INSERT INTO credit_transactions (user_id, guild_id, amount, transaction_type, description, balance_after, created_at) VALUES ($1, NULL, $2, $3, $4, $5, $6)"
+                )
+                .bind(user_id)
+                .bind(default_credits)
+                .bind("grant")
+                .bind("Initial free tier credits")
+                .bind(default_credits)
+                .bind(&now)
+                .execute(p)
+                .await?;
+
+                Ok(UserCredits {
+                    user_id: user_id.to_string(),
+                    credits: default_credits,
+                    tier_id: 1,
+                    lifetime_credits_used: 0,
+                    created_at: now.clone(),
+                    updated_at: now,
+                })
+            }
+        }
+    }
+
+    /// Get user's transaction history
+    pub async fn get_transactions(
+        &self,
+        pool: &DatabasePool,
+        user_id: &str,
+        limit: i64,
+    ) -> Result<Vec<CreditTransaction>> {
+        match pool {
+            DatabasePool::Sqlite(p) => {
+                let rows = sqlx::query(
+                    "SELECT id, user_id, guild_id, amount, transaction_type, description, balance_after, created_at FROM credit_transactions WHERE user_id = ? ORDER BY created_at DESC LIMIT ?"
+                )
+                .bind(user_id)
+                .bind(limit)
+                .fetch_all(p)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CreditTransaction {
+                    id: r.get(0),
+                    user_id: r.get(1),
+                    guild_id: r.get(2),
+                    amount: r.get(3),
+                    transaction_type: r.get(4),
+                    description: r.get(5),
+                    balance_after: r.get(6),
+                    created_at: r.get(7),
+                }).collect())
+            }
+            DatabasePool::Postgres(p) => {
+                let rows = sqlx::query(
+                    "SELECT id, user_id, guild_id, amount, transaction_type, description, balance_after, created_at FROM credit_transactions WHERE user_id = $1 ORDER BY created_at DESC LIMIT $2"
+                )
+                .bind(user_id)
+                .bind(limit)
+                .fetch_all(p)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CreditTransaction {
+                    id: r.get(0),
+                    user_id: r.get(1),
+                    guild_id: r.get(2),
+                    amount: r.get(3),
+                    transaction_type: r.get(4),
+                    description: r.get(5),
+                    balance_after: r.get(6),
+                    created_at: r.get(7),
+                }).collect())
+            }
+        }
+    }
+
+    /// Set user tier
+    pub async fn set_user_tier(
+        &self,
+        pool: &DatabasePool,
+        user_id: &str,
+        tier: TierLevel,
+    ) -> Result<()> {
+        let now = Utc::now().to_rfc3339();
+
+        match pool {
+            DatabasePool::Sqlite(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET tier_id = ?, updated_at = ? WHERE user_id = ?"
+                )
+                .bind(tier as i32)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+            }
+            DatabasePool::Postgres(p) => {
+                sqlx::query(
+                    "UPDATE user_credits SET tier_id = $1, updated_at = $2 WHERE user_id = $3"
+                )
+                .bind(tier as i32)
+                .bind(&now)
+                .bind(user_id)
+                .execute(p)
+                .await?;
+            }
+        }
+
+        info!("Set user {} tier to {:?}", user_id, tier);
+        Ok(())
+    }
+}
+
+/// Create credit system tables
+pub async fn create_credit_tables(pool: &DatabasePool) -> Result<()> {
+    match pool {
+        DatabasePool::Sqlite(p) => {
+            sqlx::query(
+                r#"
+                CREATE TABLE IF NOT EXISTS user_credits (
+                    user_id TEXT PRIMARY KEY,
+                    credits INTEGER NOT NULL DEFAULT 50,
+                    tier_id INTEGER NOT NULL DEFAULT 1,
+                    lifetime_credits_used INTEGER NOT NULL DEFAULT 0,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                )
+                "#
+            )
+            .execute(p)
+            .await?;
+
+            sqlx::query(
+                r#"
+                CREATE TABLE IF NOT EXISTS credit_transactions (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    user_id TEXT NOT NULL,
+                    guild_id TEXT,
+                    amount INTEGER NOT NULL,
+                    transaction_type TEXT NOT NULL,
+                    description TEXT NOT NULL,
+                    balance_after INTEGER NOT NULL,
+                    created_at TEXT NOT NULL
+                )
+                "#
+            )
+            .execute(p)
+            .await?;
+
+            sqlx::query("CREATE INDEX IF NOT EXISTS idx_credit_transactions_user ON credit_transactions(user_id)")
+                .execute(p)
+                .await?;
+        }
+        DatabasePool::Postgres(p) => {
+            sqlx::query(
+                r#"
+                CREATE TABLE IF NOT EXISTS user_credits (
+                    user_id TEXT PRIMARY KEY,
+                    credits BIGINT NOT NULL DEFAULT 50,
+                    tier_id INTEGER NOT NULL DEFAULT 1,
+                    lifetime_credits_used BIGINT NOT NULL DEFAULT 0,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                )
+                "#
+            )
+            .execute(p)
+            .await?;
+
+            sqlx::query(
+                r#"
+                CREATE TABLE IF NOT EXISTS credit_transactions (
+                    id BIGSERIAL PRIMARY KEY,
+                    user_id TEXT NOT NULL,
+                    guild_id TEXT,
+                    amount BIGINT NOT NULL,
+                    transaction_type TEXT NOT NULL,
+                    description TEXT NOT NULL,
+                    balance_after BIGINT NOT NULL,
+                    created_at TEXT NOT NULL
+                )
+                "#
+            )
+            .execute(p)
+            .await?;
+
+            sqlx::query("CREATE INDEX IF NOT EXISTS idx_credit_transactions_user ON credit_transactions(user_id)")
+                .execute(p)
+                .await?;
+        }
+    }
+
+    info!("Credit system tables created");
+    Ok(())
+}

backend_api/src/database.rs

@@ -0,0 +1,781 @@
+use anyhow::Result;
+use chrono::Utc;
+use sqlx::{sqlite::SqlitePool, postgres::PgPool, Row};
+use crate::models::{CacheEntry, CacheStats};
+use crate::config::DatabaseType;
+
+pub enum DatabasePool {
+    Sqlite(SqlitePool),
+    Postgres(PgPool),
+}
+
+pub struct Database {
+    pool: DatabasePool,
+}
+
+impl Database {
+    /// Get a reference to the underlying database pool
+    pub fn pool(&self) -> &DatabasePool {
+        &self.pool
+    }
+
+    pub async fn new(database_url: &str, db_type: DatabaseType) -> Result<Self> {
+        let pool = match db_type {
+            DatabaseType::Sqlite => {
+                let pool = SqlitePool::connect(database_url).await?;
+                DatabasePool::Sqlite(pool)
+            }
+            DatabaseType::Postgres => {
+                let pool = PgPool::connect(database_url).await?;
+                DatabasePool::Postgres(pool)
+            }
+        };
+
+        let db = Self { pool };
+        db.create_tables().await?;
+        db.initialize_stats().await?;
+        db.create_indexes().await?;
+
+        Ok(db)
+    }
+
+    async fn create_tables(&self) -> Result<()> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS cache (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        checksum TEXT NOT NULL UNIQUE,
+                        text TEXT NOT NULL,
+                        summary TEXT NOT NULL,
+                        provider TEXT NOT NULL,
+                        model TEXT NOT NULL,
+                        guild_id TEXT NOT NULL,
+                        user_id TEXT NOT NULL,
+                        channel_id TEXT,
+                        temperature REAL,
+                        max_tokens INTEGER,
+                        top_p REAL,
+                        system_prompt TEXT,
+                        created_at TEXT NOT NULL,
+                        last_accessed TEXT NOT NULL,
+                        access_count INTEGER DEFAULT 1
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS rate_limits (
+                        id INTEGER PRIMARY KEY AUTOINCREMENT,
+                        guild_id TEXT NOT NULL,
+                        user_id TEXT NOT NULL,
+                        window_start TEXT NOT NULL,
+                        request_count INTEGER DEFAULT 1,
+                        UNIQUE(guild_id, user_id, window_start)
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS stats (
+                        id INTEGER PRIMARY KEY CHECK (id = 1),
+                        total_hits INTEGER DEFAULT 0,
+                        total_misses INTEGER DEFAULT 0
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+            }
+            DatabasePool::Postgres(pool) => {
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS cache (
+                        id BIGSERIAL PRIMARY KEY,
+                        checksum TEXT NOT NULL UNIQUE,
+                        text TEXT NOT NULL,
+                        summary TEXT NOT NULL,
+                        provider TEXT NOT NULL,
+                        model TEXT NOT NULL,
+                        guild_id TEXT NOT NULL,
+                        user_id TEXT NOT NULL,
+                        channel_id TEXT,
+                        temperature REAL,
+                        max_tokens INTEGER,
+                        top_p REAL,
+                        system_prompt TEXT,
+                        created_at TEXT NOT NULL,
+                        last_accessed TEXT NOT NULL,
+                        access_count BIGINT DEFAULT 1
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS rate_limits (
+                        id BIGSERIAL PRIMARY KEY,
+                        guild_id TEXT NOT NULL,
+                        user_id TEXT NOT NULL,
+                        window_start TEXT NOT NULL,
+                        request_count BIGINT DEFAULT 1,
+                        UNIQUE(guild_id, user_id, window_start)
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+
+                sqlx::query(
+                    r#"
+                    CREATE TABLE IF NOT EXISTS stats (
+                        id INTEGER PRIMARY KEY CHECK (id = 1),
+                        total_hits BIGINT DEFAULT 0,
+                        total_misses BIGINT DEFAULT 0
+                    )
+                    "#,
+                )
+                .execute(pool)
+                .await?;
+            }
+        }
+        Ok(())
+    }
+
+    async fn initialize_stats(&self) -> Result<()> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                sqlx::query("INSERT OR IGNORE INTO stats (id, total_hits, total_misses) VALUES (1, 0, 0)")
+                    .execute(pool)
+                    .await?;
+            }
+            DatabasePool::Postgres(pool) => {
+                sqlx::query("INSERT INTO stats (id, total_hits, total_misses) VALUES (1, 0, 0) ON CONFLICT (id) DO NOTHING")
+                    .execute(pool)
+                    .await?;
+            }
+        }
+        Ok(())
+    }
+
+    async fn create_indexes(&self) -> Result<()> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_checksum ON cache(checksum)")
+                    .execute(pool)
+                    .await?;
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_guild ON cache(guild_id)")
+                    .execute(pool)
+                    .await?;
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_user ON cache(user_id)")
+                    .execute(pool)
+                    .await?;
+            }
+            DatabasePool::Postgres(pool) => {
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_checksum ON cache(checksum)")
+                    .execute(pool)
+                    .await?;
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_guild ON cache(guild_id)")
+                    .execute(pool)
+                    .await?;
+                sqlx::query("CREATE INDEX IF NOT EXISTS idx_cache_user ON cache(user_id)")
+                    .execute(pool)
+                    .await?;
+            }
+        }
+        Ok(())
+    }
+
+    pub async fn get_cache_by_checksum(&self, checksum: &str) -> Result<Option<CacheEntry>> {
+        let now = Utc::now().to_rfc3339();
+
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                // Update access count and last_accessed
+                sqlx::query(
+                    "UPDATE cache SET access_count = access_count + 1, last_accessed = ? WHERE checksum = ?"
+                )
+                .bind(&now)
+                .bind(checksum)
+                .execute(pool)
+                .await?;
+
+                // Increment cache hit
+                sqlx::query("UPDATE stats SET total_hits = total_hits + 1 WHERE id = 1")
+                    .execute(pool)
+                    .await?;
+
+                let row = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE checksum = ?"
+                )
+                .bind(checksum)
+                .fetch_optional(pool)
+                .await?;
+
+                Ok(row.map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }))
+            }
+            DatabasePool::Postgres(pool) => {
+                // Update access count and last_accessed
+                sqlx::query(
+                    "UPDATE cache SET access_count = access_count + 1, last_accessed = $1 WHERE checksum = $2"
+                )
+                .bind(&now)
+                .bind(checksum)
+                .execute(pool)
+                .await?;
+
+                // Increment cache hit
+                sqlx::query("UPDATE stats SET total_hits = total_hits + 1 WHERE id = 1")
+                    .execute(pool)
+                    .await?;
+
+                let row = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE checksum = $1"
+                )
+                .bind(checksum)
+                .fetch_optional(pool)
+                .await?;
+
+                Ok(row.map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }))
+            }
+        }
+    }
+
+    pub async fn insert_cache(
+        &self,
+        checksum: &str,
+        text: &str,
+        summary: &str,
+        provider: &str,
+        model: &str,
+        guild_id: &str,
+        user_id: &str,
+        channel_id: Option<&str>,
+        temperature: Option<f32>,
+        max_tokens: Option<u32>,
+        top_p: Option<f32>,
+        system_prompt: Option<&str>,
+    ) -> Result<i64> {
+        let now = Utc::now().to_rfc3339();
+
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                // Increment cache miss
+                sqlx::query("UPDATE stats SET total_misses = total_misses + 1 WHERE id = 1")
+                    .execute(pool)
+                    .await?;
+
+                let result = sqlx::query(
+                    r#"
+                    INSERT INTO cache (checksum, text, summary, provider, model, guild_id, user_id, channel_id, temperature, max_tokens, top_p, system_prompt, created_at, last_accessed)
+                    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+                    "#
+                )
+                .bind(checksum)
+                .bind(text)
+                .bind(summary)
+                .bind(provider)
+                .bind(model)
+                .bind(guild_id)
+                .bind(user_id)
+                .bind(channel_id)
+                .bind(temperature)
+                .bind(max_tokens.map(|v| v as i64))
+                .bind(top_p)
+                .bind(system_prompt)
+                .bind(&now)
+                .bind(&now)
+                .execute(pool)
+                .await?;
+
+                Ok(result.last_insert_rowid())
+            }
+            DatabasePool::Postgres(pool) => {
+                // Increment cache miss
+                sqlx::query("UPDATE stats SET total_misses = total_misses + 1 WHERE id = 1")
+                    .execute(pool)
+                    .await?;
+
+                let result = sqlx::query(
+                    r#"
+                    INSERT INTO cache (checksum, text, summary, provider, model, guild_id, user_id, channel_id, temperature, max_tokens, top_p, system_prompt, created_at, last_accessed)
+                    VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
+                    RETURNING id
+                    "#
+                )
+                .bind(checksum)
+                .bind(text)
+                .bind(summary)
+                .bind(provider)
+                .bind(model)
+                .bind(guild_id)
+                .bind(user_id)
+                .bind(channel_id)
+                .bind(temperature)
+                .bind(max_tokens.map(|v| v as i32))
+                .bind(top_p)
+                .bind(system_prompt)
+                .bind(&now)
+                .bind(&now)
+                .fetch_one(pool)
+                .await?;
+
+                Ok(result.get(0))
+            }
+        }
+    }
+
+    pub async fn get_all_cache_entries(&self, limit: Option<i64>, offset: Option<i64>) -> Result<Vec<CacheEntry>> {
+        let limit = limit.unwrap_or(100);
+        let offset = offset.unwrap_or(0);
+
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache ORDER BY last_accessed DESC LIMIT ? OFFSET ?"
+                )
+                .bind(limit)
+                .bind(offset)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+            DatabasePool::Postgres(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache ORDER BY last_accessed DESC LIMIT $1 OFFSET $2"
+                )
+                .bind(limit)
+                .bind(offset)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+        }
+    }
+
+    pub async fn get_cache_by_guild(&self, guild_id: &str) -> Result<Vec<CacheEntry>> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE guild_id = ? ORDER BY last_accessed DESC"
+                )
+                .bind(guild_id)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+            DatabasePool::Postgres(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE guild_id = $1 ORDER BY last_accessed DESC"
+                )
+                .bind(guild_id)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+        }
+    }
+
+    pub async fn get_cache_by_user(&self, user_id: &str) -> Result<Vec<CacheEntry>> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE user_id = ? ORDER BY last_accessed DESC"
+                )
+                .bind(user_id)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+            DatabasePool::Postgres(pool) => {
+                let rows = sqlx::query(
+                    "SELECT id, checksum, text, summary, provider, model, guild_id, user_id, channel_id, created_at, last_accessed, access_count FROM cache WHERE user_id = $1 ORDER BY last_accessed DESC"
+                )
+                .bind(user_id)
+                .fetch_all(pool)
+                .await?;
+
+                Ok(rows.into_iter().map(|r| CacheEntry {
+                    id: r.get(0),
+                    checksum: r.get(1),
+                    text: r.get(2),
+                    summary: r.get(3),
+                    provider: r.get(4),
+                    model: r.get(5),
+                    guild_id: r.get(6),
+                    user_id: r.get(7),
+                    channel_id: r.get(8),
+                    created_at: r.get(9),
+                    last_accessed: r.get(10),
+                    access_count: r.get(11),
+                }).collect())
+            }
+        }
+    }
+
+    pub async fn delete_cache_by_id(&self, id: i64) -> Result<u64> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE id = ?")
+                    .bind(id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+            DatabasePool::Postgres(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE id = $1")
+                    .bind(id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+        }
+    }
+
+    pub async fn delete_cache_by_guild(&self, guild_id: &str) -> Result<u64> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE guild_id = ?")
+                    .bind(guild_id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+            DatabasePool::Postgres(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE guild_id = $1")
+                    .bind(guild_id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+        }
+    }
+
+    pub async fn delete_cache_by_user(&self, user_id: &str) -> Result<u64> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE user_id = ?")
+                    .bind(user_id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+            DatabasePool::Postgres(pool) => {
+                let result = sqlx::query("DELETE FROM cache WHERE user_id = $1")
+                    .bind(user_id)
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+        }
+    }
+
+    pub async fn delete_all_cache(&self) -> Result<u64> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let result = sqlx::query("DELETE FROM cache")
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+            DatabasePool::Postgres(pool) => {
+                let result = sqlx::query("DELETE FROM cache")
+                    .execute(pool)
+                    .await?;
+                Ok(result.rows_affected())
+            }
+        }
+    }
+
+    pub async fn get_cache_stats(&self) -> Result<CacheStats> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                let total_entries: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM cache")
+                    .fetch_one(pool)
+                    .await?;
+
+                let stats_row = sqlx::query("SELECT total_hits, total_misses FROM stats WHERE id = 1")
+                    .fetch_one(pool)
+                    .await?;
+
+                let total_hits: i64 = stats_row.get(0);
+                let total_misses: i64 = stats_row.get(1);
+
+                let total_requests = total_hits + total_misses;
+                let hit_rate = if total_requests > 0 {
+                    (total_hits as f64 / total_requests as f64) * 100.0
+                } else {
+                    0.0
+                };
+
+                let total_size: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(LENGTH(text) + LENGTH(summary)), 0) FROM cache"
+                )
+                .fetch_one(pool)
+                .await?;
+
+                Ok(CacheStats {
+                    total_entries,
+                    total_hits,
+                    total_misses,
+                    hit_rate,
+                    total_size_bytes: total_size,
+                })
+            }
+            DatabasePool::Postgres(pool) => {
+                let total_entries: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM cache")
+                    .fetch_one(pool)
+                    .await?;
+
+                let stats_row = sqlx::query("SELECT total_hits, total_misses FROM stats WHERE id = 1")
+                    .fetch_one(pool)
+                    .await?;
+
+                let total_hits: i64 = stats_row.get(0);
+                let total_misses: i64 = stats_row.get(1);
+
+                let total_requests = total_hits + total_misses;
+                let hit_rate = if total_requests > 0 {
+                    (total_hits as f64 / total_requests as f64) * 100.0
+                } else {
+                    0.0
+                };
+
+                let total_size: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(LENGTH(text) + LENGTH(summary)), 0) FROM cache"
+                )
+                .fetch_one(pool)
+                .await?;
+
+                Ok(CacheStats {
+                    total_entries,
+                    total_hits,
+                    total_misses,
+                    hit_rate,
+                    total_size_bytes: total_size,
+                })
+            }
+        }
+    }
+
+    pub async fn _check_rate_limit(&self, guild_id: &str, user_id: &str, guild_limit: u32, user_limit: u32) -> Result<(bool, bool)> {
+        let now = Utc::now();
+        let window_start = now.format("%Y-%m-%d %H:%M").to_string();
+
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                // Clean old rate limit entries (older than 1 minute)
+                sqlx::query("DELETE FROM rate_limits WHERE window_start < datetime('now', '-1 minute')")
+                    .execute(pool)
+                    .await?;
+
+                // Check guild rate limit
+                let guild_count: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(request_count), 0) FROM rate_limits WHERE guild_id = ? AND window_start = ?"
+                )
+                .bind(guild_id)
+                .bind(&window_start)
+                .fetch_one(pool)
+                .await?;
+
+                // Check user rate limit
+                let user_count: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(request_count), 0) FROM rate_limits WHERE user_id = ? AND window_start = ?"
+                )
+                .bind(user_id)
+                .bind(&window_start)
+                .fetch_one(pool)
+                .await?;
+
+                let guild_limited = guild_count >= guild_limit as i64;
+                let user_limited = user_count >= user_limit as i64;
+
+                if !guild_limited && !user_limited {
+                    // Increment rate limit counter
+                    sqlx::query(
+                        r#"
+                        INSERT INTO rate_limits (guild_id, user_id, window_start, request_count)
+                        VALUES (?, ?, ?, 1)
+                        ON CONFLICT(guild_id, user_id, window_start) DO UPDATE SET request_count = request_count + 1
+                        "#
+                    )
+                    .bind(guild_id)
+                    .bind(user_id)
+                    .bind(&window_start)
+                    .execute(pool)
+                    .await?;
+                }
+
+                Ok((guild_limited, user_limited))
+            }
+            DatabasePool::Postgres(pool) => {
+                // Clean old rate limit entries (older than 1 minute)
+                sqlx::query("DELETE FROM rate_limits WHERE window_start < (NOW() - INTERVAL '1 minute')::TEXT")
+                    .execute(pool)
+                    .await?;
+
+                // Check guild rate limit
+                let guild_count: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(request_count), 0) FROM rate_limits WHERE guild_id = $1 AND window_start = $2"
+                )
+                .bind(guild_id)
+                .bind(&window_start)
+                .fetch_one(pool)
+                .await?;
+
+                // Check user rate limit
+                let user_count: i64 = sqlx::query_scalar(
+                    "SELECT COALESCE(SUM(request_count), 0) FROM rate_limits WHERE user_id = $1 AND window_start = $2"
+                )
+                .bind(user_id)
+                .bind(&window_start)
+                .fetch_one(pool)
+                .await?;
+
+                let guild_limited = guild_count >= guild_limit as i64;
+                let user_limited = user_count >= user_limit as i64;
+
+                if !guild_limited && !user_limited {
+                    // Increment rate limit counter
+                    sqlx::query(
+                        r#"
+                        INSERT INTO rate_limits (guild_id, user_id, window_start, request_count)
+                        VALUES ($1, $2, $3, 1)
+                        ON CONFLICT(guild_id, user_id, window_start) DO UPDATE SET request_count = rate_limits.request_count + 1
+                        "#
+                    )
+                    .bind(guild_id)
+                    .bind(user_id)
+                    .bind(&window_start)
+                    .execute(pool)
+                    .await?;
+                }
+
+                Ok((guild_limited, user_limited))
+            }
+        }
+    }
+
+    /// Check if the database connection is healthy
+    pub async fn health_check(&self) -> Result<bool> {
+        match &self.pool {
+            DatabasePool::Sqlite(pool) => {
+                sqlx::query("SELECT 1")
+                    .fetch_one(pool)
+                    .await?;
+                Ok(true)
+            }
+            DatabasePool::Postgres(pool) => {
+                sqlx::query("SELECT 1")
+                    .fetch_one(pool)
+                    .await?;
+                Ok(true)
+            }
+        }
+    }
+}

backend_api/src/llm.rs

@@ -0,0 +1,402 @@
+use anyhow::{anyhow, Result};
+use reqwest::Client;
+use serde::{Deserialize, Serialize};
+use crate::config::Config;
+use crate::models::{SummarizeRequest, TokenUsage};
+use crate::v1::enums::LlmProvider;
+use crate::claude_models::ClaudeModelType;
+
+pub struct LlmClient {
+    client: Client,
+    config: Config,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicRequest {
+    model: String,
+    max_tokens: u32,
+    temperature: f32,
+    messages: Vec<AnthropicMessage>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    top_p: Option<f32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicMessage {
+    role: String,
+    content: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicResponse {
+    content: Vec<AnthropicContent>,
+    model: String,
+    usage: AnthropicUsage,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicUsage {
+    input_tokens: u32,
+    output_tokens: u32,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct AnthropicContent {
+    text: String,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct OllamaRequest {
+    model: String,
+    prompt: String,
+    stream: bool,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    system: Option<String>,
+    options: OllamaOptions,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct OllamaOptions {
+    temperature: f32,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    top_p: Option<f32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    num_predict: Option<i32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct OllamaResponse {
+    response: String,
+    model: String,
+    prompt_eval_count: Option<u32>,
+    eval_count: Option<u32>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct _OllamaModelInfo {
+    pub name: String,
+    pub modified_at: String,
+    pub size: i64,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+struct _OllamaListResponse {
+    models: Vec<_OllamaModelInfo>,
+}
+
+impl LlmClient {
+    pub fn new(config: Config) -> Self {
+        Self {
+            client: Client::new(),
+            config,
+        }
+    }
+
+    pub async fn summarize(&self, request: &SummarizeRequest) -> Result<(String, String, TokenUsage)> {
+        match request.provider {
+            LlmProvider::Anthropic => self.summarize_anthropic(request).await,
+            LlmProvider::Ollama => self.summarize_ollama(request).await,
+            LlmProvider::Lmstudio => self.summarize_lmstudio(request).await,
+        }
+    }
+
+    async fn summarize_anthropic(&self, request: &SummarizeRequest) -> Result<(String, String, TokenUsage)> {
+        let anthropic_config = self.config.anthropic.as_ref()
+            .ok_or_else(|| anyhow!("Anthropic config not found"))?;
+        
+        let model = request.model.clone()
+            .unwrap_or_else(|| anthropic_config.model.clone());
+        
+        let max_tokens = request.max_tokens
+            .unwrap_or(anthropic_config.max_tokens);
+        
+        let temperature = request.temperature
+            .unwrap_or(anthropic_config.temperature);
+
+        let system_prompt = if let Some(ref style) = request.style {
+            style.to_system_prompt()
+        } else {
+            request.system_prompt.clone()
+                .unwrap_or_else(|| "You are a helpful assistant that summarizes text concisely and accurately. Provide a clear, well-structured summary of the given text.".to_string())
+        };
+
+        let anthropic_request = AnthropicRequest {
+            model: model.clone(),
+            max_tokens,
+            temperature,
+            messages: vec![
+                AnthropicMessage {
+                    role: "user".to_string(),
+                    content: format!("Please summarize the following text:\n\n{}", request.text),
+                }
+            ],
+            system: Some(system_prompt),
+            top_p: request.top_p,
+        };
+
+        let response = self.client
+            .post(format!("{}/messages", anthropic_config.base_url))
+            .header("x-api-key", &anthropic_config.api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("content-type", "application/json")
+            .json(&anthropic_request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error_text = response.text().await?;
+            return Err(anyhow!("Anthropic API error: {}", error_text));
+        }
+
+        let anthropic_response: AnthropicResponse = response.json().await?;
+        
+        let summary = anthropic_response.content
+            .first()
+            .map(|c| c.text.clone())
+            .ok_or_else(|| anyhow!("No content in Anthropic response"))?;
+
+        let token_usage = TokenUsage {
+            input_tokens: anthropic_response.usage.input_tokens,
+            output_tokens: anthropic_response.usage.output_tokens,
+            total_tokens: anthropic_response.usage.input_tokens + anthropic_response.usage.output_tokens,
+            estimated_cost_usd: Some(calculate_anthropic_cost(
+                &model,
+                anthropic_response.usage.input_tokens,
+                anthropic_response.usage.output_tokens,
+            )),
+        };
+
+        Ok((summary, model, token_usage))
+    }
+
+    async fn summarize_ollama(&self, request: &SummarizeRequest) -> Result<(String, String, TokenUsage)> {
+        let ollama_config = self.config.ollama.as_ref()
+            .ok_or_else(|| anyhow!("Ollama config not found"))?;
+        
+        let model = request.model.clone()
+            .unwrap_or_else(|| ollama_config.model.clone());
+        
+        let temperature = request.temperature
+            .unwrap_or(ollama_config.temperature);
+
+        let system_prompt = if let Some(ref style) = request.style {
+            style.to_system_prompt()
+        } else {
+            request.system_prompt.clone()
+                .unwrap_or_else(|| "You are a helpful assistant that summarizes text concisely and accurately. Provide a clear, well-structured summary of the given text.".to_string())
+        };
+
+        let prompt = format!("Please summarize the following text:\n\n{}", request.text);
+
+        let ollama_request = OllamaRequest {
+            model: model.clone(),
+            prompt,
+            stream: false,
+            system: Some(system_prompt),
+            options: OllamaOptions {
+                temperature,
+                top_p: request.top_p,
+                num_predict: request.max_tokens.map(|v| v as i32),
+            },
+        };
+
+        let response = self.client
+            .post(format!("{}/api/generate", ollama_config.base_url))
+            .json(&ollama_request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error_text = response.text().await?;
+            return Err(anyhow!("Ollama API error: {}", error_text));
+        }
+
+        let ollama_response: OllamaResponse = response.json().await?;
+        
+        let token_usage = TokenUsage {
+            input_tokens: ollama_response.prompt_eval_count.unwrap_or(0),
+            output_tokens: ollama_response.eval_count.unwrap_or(0),
+            total_tokens: ollama_response.prompt_eval_count.unwrap_or(0) + ollama_response.eval_count.unwrap_or(0),
+            estimated_cost_usd: None, // Ollama is local, no cost
+        };
+        
+        Ok((ollama_response.response, model, token_usage))
+    }
+
+    pub async fn _list_ollama_models(&self) -> Result<Vec<_OllamaModelInfo>> {
+        let ollama_config = self.config.ollama.as_ref()
+            .ok_or_else(|| anyhow!("Ollama config not found"))?;
+        
+        let response = self.client
+            .get(format!("{}/api/tags", ollama_config.base_url))
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!("Failed to list Ollama models"));
+        }
+
+        let list_response: _OllamaListResponse = response.json().await?;
+        Ok(list_response.models)
+    }
+
+    pub fn _get_anthropic_models(&self) -> Vec<String> {
+        // Return known Claude models from claude_models module
+        ClaudeModelType::all_available()
+            .into_iter()
+            .map(|m| m.id())
+            .collect()
+    }
+
+    async fn summarize_lmstudio(&self, request: &SummarizeRequest) -> Result<(String, String, TokenUsage)> {
+        let lmstudio_config = self.config.lmstudio.as_ref()
+            .ok_or_else(|| anyhow!("LMStudio config not found"))?;
+
+        let model = request.model.clone()
+            .unwrap_or_else(|| lmstudio_config.model.clone());
+
+        let temperature = request.temperature
+            .unwrap_or(lmstudio_config.temperature);
+
+        let max_tokens = request.max_tokens
+            .unwrap_or(lmstudio_config.max_tokens);
+
+        let system_prompt = if let Some(ref style) = request.style {
+            style.to_system_prompt()
+        } else {
+            request.system_prompt.clone()
+                .unwrap_or_else(|| "You are a helpful assistant that summarizes text concisely and accurately. Provide a clear, well-structured summary of the given text.".to_string())
+        };
+
+        // LMStudio uses OpenAI-compatible API
+        #[derive(Serialize)]
+        struct LmStudioRequest {
+            model: String,
+            messages: Vec<LmStudioMessage>,
+            temperature: f32,
+            max_tokens: u32,
+        }
+
+        #[derive(Serialize)]
+        struct LmStudioMessage {
+            role: String,
+            content: String,
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioResponse {
+            choices: Vec<LmStudioChoice>,
+            usage: Option<LmStudioUsage>,
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioChoice {
+            message: LmStudioResponseMessage,
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioResponseMessage {
+            content: String,
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioUsage {
+            prompt_tokens: u32,
+            completion_tokens: u32,
+            total_tokens: u32,
+        }
+
+        let lmstudio_request = LmStudioRequest {
+            model: model.clone(),
+            messages: vec![
+                LmStudioMessage {
+                    role: "system".to_string(),
+                    content: system_prompt,
+                },
+                LmStudioMessage {
+                    role: "user".to_string(),
+                    content: format!("Please summarize the following text:\n\n{}", request.text),
+                },
+            ],
+            temperature,
+            max_tokens,
+        };
+
+        let response = self.client
+            .post(format!("{}/chat/completions", lmstudio_config.base_url))
+            .json(&lmstudio_request)
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            let error_text = response.text().await?;
+            return Err(anyhow!("LMStudio API error: {}", error_text));
+        }
+
+        let lmstudio_response: LmStudioResponse = response.json().await?;
+
+        let summary = lmstudio_response.choices
+            .first()
+            .map(|c| c.message.content.clone())
+            .ok_or_else(|| anyhow!("No content in LMStudio response"))?;
+
+        let token_usage = if let Some(usage) = lmstudio_response.usage {
+            TokenUsage {
+                input_tokens: usage.prompt_tokens,
+                output_tokens: usage.completion_tokens,
+                total_tokens: usage.total_tokens,
+                estimated_cost_usd: None, // LMStudio is local, no cost
+            }
+        } else {
+            TokenUsage {
+                input_tokens: 0,
+                output_tokens: 0,
+                total_tokens: 0,
+                estimated_cost_usd: None,
+            }
+        };
+
+        Ok((summary, model, token_usage))
+    }
+
+    pub async fn _list_lmstudio_models(&self) -> Result<Vec<_OllamaModelInfo>> {
+        let lmstudio_config = self.config.lmstudio.as_ref()
+            .ok_or_else(|| anyhow!("LMStudio config not found"))?;
+
+        let response = self.client
+            .get(format!("{}/models", lmstudio_config.base_url))
+            .send()
+            .await?;
+
+        if !response.status().is_success() {
+            return Err(anyhow!("Failed to list LMStudio models"));
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioModelsResponse {
+            data: Vec<LmStudioModel>,
+        }
+
+        #[derive(Deserialize)]
+        struct LmStudioModel {
+            id: String,
+        }
+
+        let list_response: LmStudioModelsResponse = response.json().await?;
+
+        // Convert to OllamaModelInfo format for compatibility
+        Ok(list_response.data.into_iter().map(|m| _OllamaModelInfo {
+            name: m.id,
+            modified_at: "".to_string(),
+            size: 0,
+        }).collect())
+    }
+}
+
+// Calculate Anthropic API costs based on model and token usage using ClaudeModelType
+fn calculate_anthropic_cost(model: &str, input_tokens: u32, output_tokens: u32) -> f64 {
+    let claude_model = ClaudeModelType::from_id(model);
+    claude_model.calculate_cost(input_tokens, output_tokens)
+}

backend_api/src/main.rs

@@ -0,0 +1,300 @@
+mod config;
+mod models;
+mod llm;
+mod checksum;
+mod ocr;
+mod cache;
+mod database;
+mod rate_limiter;
+mod claude_models;
+mod credits;
+mod v1;
+
+use anyhow::Result;
+use poem::{listener::TcpListener, Route, EndpointExt};
+use poem::middleware::Tracing;
+use poem_openapi::OpenApiService;
+use std::sync::Arc;
+use tracing::{info, warn, error};
+
+use config::Config;
+use v1::{AppState, create_apis};
+
+/// Result of LLM provider health check
+struct LlmHealthResult {
+    available: bool,
+    error_message: Option<String>,
+}
+
+/// Performs startup health checks and returns whether the server can start.
+/// Returns Err if no LLM provider is available.
+async fn perform_startup_health_checks(state: &Arc<AppState>) -> Result<()> {
+    // Check database
+    match state.database.health_check().await {
+        Ok(_) => info!("✓ Database connection healthy"),
+        Err(e) => {
+            error!("✗ Database connection failed: {}", e);
+            return Err(anyhow::anyhow!("Database connection failed: {}", e));
+        }
+    }
+
+    let mut anthropic_available = false;
+    let mut ollama_available = false;
+    let mut lmstudio_available = false;
+    let mut anthropic_error: Option<String> = None;
+
+    // Check Anthropic API if configured
+    if let Some(ref config) = state.config.anthropic {
+        info!("Checking Anthropic API...");
+        let result = check_anthropic_health(config).await;
+        anthropic_available = result.available;
+        anthropic_error = result.error_message.clone();
+        
+        if result.available {
+            info!("✓ Anthropic API healthy");
+        } else {
+            error!("✗ Anthropic API check failed: {}", result.error_message.unwrap_or_default());
+        }
+    } else {
+        warn!("Anthropic API not configured");
+    }
+
+    // Check Ollama API if configured
+    if let Some(ref config) = state.config.ollama {
+        info!("Checking Ollama API...");
+        let result = check_ollama_health(config).await;
+        ollama_available = result.available;
+        
+        if result.available {
+            info!("✓ Ollama API healthy");
+        } else {
+            error!("✗ Ollama API check failed: {}", result.error_message.unwrap_or_default());
+        }
+    } else {
+        warn!("Ollama API not configured");
+    }
+
+    // Check LMStudio API if configured
+    if let Some(ref config) = state.config.lmstudio {
+        info!("Checking LMStudio API...");
+        let result = check_lmstudio_health(config).await;
+        lmstudio_available = result.available;
+        
+        if result.available {
+            info!("✓ LMStudio API healthy");
+        } else {
+            error!("✗ LMStudio API check failed: {}", result.error_message.unwrap_or_default());
+        }
+    } else {
+        warn!("LMStudio API not configured");
+    }
+
+    // Check if at least one LLM provider is available
+    if !anthropic_available && !ollama_available && !lmstudio_available {
+        error!("═══════════════════════════════════════════════════════════════");
+        error!("FATAL: No LLM provider is available!");
+        error!("═══════════════════════════════════════════════════════════════");
+        
+        if state.config.anthropic.is_some() {
+            if let Some(ref err) = anthropic_error {
+                if err.contains("401") || err.contains("invalid") || err.contains("authentication") {
+                    error!("Anthropic API key appears to be invalid");
+                } else if err.contains("insufficient") || err.contains("credit") || err.contains("balance") {
+                    error!("Anthropic API credits may be exhausted");
+                }
+            }
+            error!("- Anthropic: UNAVAILABLE");
+        } else {
+            error!("- Anthropic: NOT CONFIGURED");
+        }
+        
+        if state.config.ollama.is_some() {
+            error!("- Ollama: UNAVAILABLE (is the server running?)");
+        } else {
+            error!("- Ollama: NOT CONFIGURED");
+        }
+        
+        if state.config.lmstudio.is_some() {
+            error!("- LMStudio: UNAVAILABLE (is the server running?)");
+        } else {
+            error!("- LMStudio: NOT CONFIGURED");
+        }
+        
+        error!("═══════════════════════════════════════════════════════════════");
+        error!("Please configure at least one working LLM provider in config.toml");
+        error!("═══════════════════════════════════════════════════════════════");
+        
+        return Err(anyhow::anyhow!("No LLM provider available. Server cannot start."));
+    }
+
+    info!("Startup health checks completed successfully");
+    Ok(())
+}
+
+async fn check_anthropic_health(config: &config::AnthropicConfig) -> LlmHealthResult {
+    let client = reqwest::Client::new();
+
+    #[derive(serde::Serialize)]
+    struct TestRequest {
+        model: String,
+        max_tokens: u32,
+        messages: Vec<TestMessage>,
+    }
+
+    #[derive(serde::Serialize)]
+    struct TestMessage {
+        role: String,
+        content: String,
+    }
+
+    let test_request = TestRequest {
+        model: "claude-haiku-4-5-20251001".to_string(),
+        max_tokens: 10,
+        messages: vec![TestMessage {
+            role: "user".to_string(),
+            content: "Hello".to_string(),
+        }],
+    };
+
+    match client
+        .post(format!("{}/messages", config.base_url))
+        .header("x-api-key", &config.api_key)
+        .header("anthropic-version", "2023-06-01")
+        .header("content-type", "application/json")
+        .json(&test_request)
+        .send()
+        .await
+    {
+        Ok(resp) if resp.status().is_success() => LlmHealthResult {
+            available: true,
+            error_message: None,
+        },
+        Ok(resp) => {
+            let status = resp.status();
+            let error_text = resp.text().await.unwrap_or_else(|_| "Unknown error".to_string());
+            LlmHealthResult {
+                available: false,
+                error_message: Some(format!("HTTP {} - {}", status, error_text)),
+            }
+        }
+        Err(e) => LlmHealthResult {
+            available: false,
+            error_message: Some(format!("Connection failed: {}", e)),
+        },
+    }
+}
+
+async fn check_ollama_health(config: &config::OllamaConfig) -> LlmHealthResult {
+    let client = reqwest::Client::new();
+
+    match client
+        .get(format!("{}/api/tags", config.base_url))
+        .send()
+        .await
+    {
+        Ok(resp) if resp.status().is_success() => LlmHealthResult {
+            available: true,
+            error_message: None,
+        },
+        Ok(resp) => LlmHealthResult {
+            available: false,
+            error_message: Some(format!("HTTP {}", resp.status())),
+        },
+        Err(e) => LlmHealthResult {
+            available: false,
+            error_message: Some(format!("Connection failed: {}", e)),
+        },
+    }
+}
+
+async fn check_lmstudio_health(config: &config::LmStudioConfig) -> LlmHealthResult {
+    let client = reqwest::Client::new();
+
+    match client
+        .get(format!("{}/models", config.base_url))
+        .send()
+        .await
+    {
+        Ok(resp) if resp.status().is_success() => LlmHealthResult {
+            available: true,
+            error_message: None,
+        },
+        Ok(resp) => LlmHealthResult {
+            available: false,
+            error_message: Some(format!("HTTP {}", resp.status())),
+        },
+        Err(e) => LlmHealthResult {
+            available: false,
+            error_message: Some(format!("Connection failed: {}", e)),
+        },
+    }
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Initialize tracing
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| tracing_subscriber::EnvFilter::new("info")),
+        )
+        .init();
+
+    info!("Starting Summarizer API v1...");
+
+    // Load configuration
+    let config = Config::load("./src/config/config.toml")?;
+    info!("Configuration loaded");
+
+    // Create app state with in-memory cache, database, and rate limiter
+    let state = Arc::new(AppState::new(config.clone()).await?);
+    info!("App state initialized with hybrid cache (memory + database) and rate limiter");
+
+    // Perform startup health checks - exit if no LLM is available
+    info!("Performing startup health checks...");
+    perform_startup_health_checks(&state).await?;
+
+    // Create versioned APIs
+    let (summarize_api, cache_api, models_api, ocr_api, health_api, credits_api) = create_apis(state.clone());
+
+    // Combine all APIs into a single OpenAPI service
+    let api_service = OpenApiService::new(
+        (summarize_api, cache_api, models_api, ocr_api, health_api, credits_api),
+        "Summarizer API",
+        "1.0"
+    )
+    .server(format!("http://{}:{}/api/v1", config.server.host, config.server.port));
+
+    let ui = api_service.swagger_ui();
+    let spec = api_service.spec_endpoint();
+
+    // Build routes
+    let app = Route::new()
+        .nest("/api/v1", api_service)
+        .nest("/docs", ui)
+        .nest("/spec", spec)
+        .with(Tracing);
+
+    let addr = format!("{}:{}", config.server.host, config.server.port);
+    info!("Starting server on {}", addr);
+    info!("API documentation available at http://{}/docs", addr);
+    info!("API v1 endpoints available at http://{}/api/v1", addr);
+
+    // Start background cleanup task
+    let cleanup_state = state.clone();
+    tokio::spawn(async move {
+        let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(300)); // 5 minutes
+        loop {
+            interval.tick().await;
+            cleanup_state.cache.cleanup_expired().await;
+            cleanup_state.rate_limiter.cleanup_expired().await;
+            info!("Cleaned up expired cache and rate limit entries");
+        }
+    });
+
+    poem::Server::new(TcpListener::bind(&addr))
+        .run(app)
+        .await?;
+
+    Ok(())
+}

backend_api/src/models.rs

@@ -0,0 +1,241 @@
+use poem_openapi::Object;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+pub use crate::v1::enums::{LlmProvider, SummarizationStyle};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object, Validate)]
+pub struct SummarizeRequest {
+    /// The text to summarize
+    #[validate(length(min = 1, max = 100000, message = "Text must be between 1 and 100000 characters"))]
+    pub text: String,
+    /// LLM provider (anthropic or ollama)
+    pub provider: LlmProvider,
+    /// Model name (optional, uses default from config)
+    #[validate(length(min = 1, max = 100))]
+    pub model: Option<String>,
+    /// Temperature (0.0 to 2.0)
+    #[validate(range(min = 0.0, max = 2.0))]
+    pub temperature: Option<f32>,
+    /// Max tokens for the response
+    #[validate(range(min = 1, max = 100000))]
+    pub max_tokens: Option<u32>,
+    /// Top P sampling (0.0 to 1.0)
+    #[validate(range(min = 0.0, max = 1.0))]
+    pub top_p: Option<f32>,
+    /// Predefined summarization style (overrides system_prompt if provided)
+    pub style: Option<SummarizationStyle>,
+    /// Custom system prompt (optional, ignored if style is set)
+    #[validate(length(max = 5000))]
+    pub system_prompt: Option<String>,
+    /// Discord guild ID
+    #[validate(length(min = 1, max = 50))]
+    pub guild_id: String,
+    /// Discord user ID
+    #[validate(length(min = 1, max = 50))]
+    pub user_id: String,
+    /// Discord channel ID (optional)
+    #[validate(length(min = 1, max = 50))]
+    pub channel_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SummarizeResponse {
+    /// The generated summary
+    pub summary: String,
+    /// Model used
+    pub model: String,
+    /// Provider used
+    pub provider: String,
+    /// Whether this was served from cache
+    pub from_cache: bool,
+    /// Request checksum
+    pub checksum: String,
+    /// Timestamp
+    pub timestamp: String,
+    /// Token usage information
+    pub token_usage: Option<TokenUsage>,
+    /// Processing time in milliseconds
+    pub processing_time_ms: Option<u64>,
+    /// Summarization style used
+    pub style_used: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct TokenUsage {
+    /// Input tokens (prompt)
+    pub input_tokens: u32,
+    /// Output tokens (completion)
+    pub output_tokens: u32,
+    /// Total tokens used
+    pub total_tokens: u32,
+    /// Estimated cost in USD (if available)
+    pub estimated_cost_usd: Option<f64>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct LlmInfo {
+    /// Provider name
+    pub provider: String,
+    /// Model name
+    pub model: String,
+    /// Model version (if available)
+    pub version: Option<String>,
+    /// Whether this model is available
+    pub available: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct CacheEntry {
+    /// Cache entry ID
+    pub id: i64,
+    /// Request checksum
+    pub checksum: String,
+    /// Original text
+    pub text: String,
+    /// Generated summary
+    pub summary: String,
+    /// Provider used
+    pub provider: String,
+    /// Model used
+    pub model: String,
+    /// Guild ID
+    pub guild_id: String,
+    /// User ID
+    pub user_id: String,
+    /// Channel ID
+    pub channel_id: Option<String>,
+    /// Created timestamp
+    pub created_at: String,
+    /// Last accessed timestamp
+    pub last_accessed: String,
+    /// Access count
+    pub access_count: i64,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct CacheStats {
+    /// Total cache entries
+    pub total_entries: i64,
+    /// Total cache hits
+    pub total_hits: i64,
+    /// Total cache misses
+    pub total_misses: i64,
+    /// Cache hit rate (percentage)
+    pub hit_rate: f64,
+    /// Total size in bytes (approximate)
+    pub total_size_bytes: i64,
+}
+
+#[allow(dead_code)]
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct RateLimitInfo {
+    /// Guild ID
+    pub guild_id: String,
+    /// User ID
+    pub user_id: String,
+    /// Requests in current window
+    pub requests_count: i64,
+    /// Window start time
+    pub window_start: String,
+    /// Whether rate limit is exceeded
+    pub is_limited: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct DeleteCacheRequest {
+    /// Cache entry ID to delete (optional)
+    pub id: Option<i64>,
+    /// Delete all entries for a guild (optional)
+    pub guild_id: Option<String>,
+    /// Delete all entries for a user (optional)
+    pub user_id: Option<String>,
+    /// Delete all entries (use with caution)
+    pub delete_all: Option<bool>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct ErrorResponse {
+    pub success: bool,
+    pub error: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SuccessResponse {
+    pub success: bool,
+    pub message: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object, Validate)]
+pub struct OcrSummarizeRequest {
+    /// LLM provider (anthropic or ollama)
+    pub provider: LlmProvider,
+    /// Model name (optional, uses default from config)
+    #[validate(length(min = 1, max = 100))]
+    pub model: Option<String>,
+    /// Temperature (0.0 to 2.0)
+    #[validate(range(min = 0.0, max = 2.0))]
+    pub temperature: Option<f32>,
+    /// Max tokens for the response
+    #[validate(range(min = 1, max = 100000))]
+    pub max_tokens: Option<u32>,
+    /// Top P sampling (0.0 to 1.0)
+    #[validate(range(min = 0.0, max = 1.0))]
+    pub top_p: Option<f32>,
+    /// Predefined summarization style
+    pub style: Option<SummarizationStyle>,
+    /// Custom system prompt (optional)
+    #[validate(length(max = 5000))]
+    pub system_prompt: Option<String>,
+    /// Discord guild ID
+    #[validate(length(min = 1, max = 50))]
+    pub guild_id: String,
+    /// Discord user ID
+    #[validate(length(min = 1, max = 50))]
+    pub user_id: String,
+    /// Discord channel ID (optional)
+    #[validate(length(min = 1, max = 50))]
+    pub channel_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct OcrSummarizeResponse {
+    /// Extracted text from OCR
+    pub extracted_text: String,
+    /// The generated summary
+    pub summary: String,
+    /// Model used
+    pub model: String,
+    /// Provider used
+    pub provider: String,
+    /// Whether summary was served from cache
+    pub from_cache: bool,
+    /// Request checksum
+    pub checksum: String,
+    /// Timestamp
+    pub timestamp: String,
+    /// Token usage information
+    pub token_usage: Option<TokenUsage>,
+    /// OCR processing time in milliseconds
+    pub ocr_time_ms: u64,
+    /// Summarization processing time in milliseconds
+    pub summarization_time_ms: Option<u64>,
+    /// Total processing time in milliseconds
+    pub total_time_ms: u64,
+    /// Summarization style used
+    pub style_used: Option<String>,
+    /// Image dimensions
+    pub image_info: ImageInfo,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct ImageInfo {
+    /// Image width in pixels
+    pub width: u32,
+    /// Image height in pixels
+    pub height: u32,
+    /// Image format (e.g., PNG, JPEG)
+    pub format: String,
+    /// File size in bytes
+    pub size_bytes: usize,
+}

backend_api/src/ocr.rs

@@ -0,0 +1,69 @@
+use anyhow::{anyhow, Result};
+use crate::models::ImageInfo;
+
+#[cfg(feature = "ocr")]
+use tesseract::Tesseract;
+#[cfg(feature = "ocr")]
+use image::ImageFormat;
+#[cfg(feature = "ocr")]
+use std::io::Cursor;
+
+pub struct OcrProcessor;
+
+impl OcrProcessor {
+    pub fn new() -> Self {
+        Self
+    }
+
+    #[cfg(feature = "ocr")]
+    pub async fn extract_text_from_image(&self, image_data: &[u8]) -> Result<(String, ImageInfo, u64)> {
+        let start = std::time::Instant::now();
+        
+        let img = image::load_from_memory(image_data)
+            .map_err(|e| anyhow!("Failed to load image: {}", e))?;
+        
+        let format = image::guess_format(image_data)
+            .map_err(|e| anyhow!("Failed to detect image format: {}", e))?;
+        
+        let image_info = ImageInfo {
+            width: img.width(),
+            height: img.height(),
+            format: format!("{:?}", format),
+            size_bytes: image_data.len(),
+        };
+        
+        
+        let gray_img = img.to_luma8();
+        
+        // Save to temporary buffer for Tesseract
+        let mut buffer = Vec::new();
+        let mut cursor = Cursor::new(&mut buffer);
+        gray_img.write_to(&mut cursor, ImageFormat::Png)
+            .map_err(|e| anyhow!("Failed to encode image: {}", e))?;
+        
+        let tesseract = Tesseract::new(None, Some("eng"))
+            .map_err(|e| anyhow!("Failed to initialize Tesseract: {}", e))?;
+        
+        let text = tesseract
+            .set_image_from_mem(&buffer)
+            .map_err(|e| anyhow!("Failed to set image: {}", e))?
+            .get_text()
+            .map_err(|e| anyhow!("Failed to extract text: {}", e))?;
+        
+        let ocr_time_ms = start.elapsed().as_millis() as u64;
+        
+
+        let cleaned_text = text.trim().to_string();
+        
+        if cleaned_text.is_empty() {
+            return Err(anyhow!("No text found in image"));
+        }
+        
+        Ok((cleaned_text, image_info, ocr_time_ms))
+    }
+    
+    #[cfg(not(feature = "ocr"))]
+    pub async fn extract_text_from_image(&self, _image_data: &[u8]) -> Result<(String, ImageInfo, u64)> {
+        Err(anyhow!("OCR feature is not enabled. Rebuild with --features ocr"))
+    }
+}

backend_api/src/rate_limiter.rs

@@ -0,0 +1,100 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+use tokio::sync::RwLock;
+use chrono::{DateTime, Utc, Duration};
+
+#[derive(Clone)]
+struct RateLimitEntry {
+    count: u32,
+    window_start: DateTime<Utc>,
+}
+
+pub struct RateLimiter {
+    guild_limits: Arc<RwLock<HashMap<String, RateLimitEntry>>>,
+    user_limits: Arc<RwLock<HashMap<String, RateLimitEntry>>>,
+    window_seconds: i64,
+}
+
+impl RateLimiter {
+    pub fn new(window_seconds: i64) -> Self {
+        Self {
+            guild_limits: Arc::new(RwLock::new(HashMap::new())),
+            user_limits: Arc::new(RwLock::new(HashMap::new())),
+            window_seconds,
+        }
+    }
+
+    pub async fn check_rate_limit(
+        &self,
+        guild_id: &str,
+        user_id: &str,
+        guild_limit: u32,
+        user_limit: u32,
+    ) -> (bool, bool) {
+        let now = Utc::now();
+        let window_duration = Duration::seconds(self.window_seconds);
+
+        // Check guild rate limit
+        let mut guild_limits = self.guild_limits.write().await;
+        let guild_limited = if let Some(entry) = guild_limits.get_mut(guild_id) {
+            if now - entry.window_start > window_duration {
+                // Reset window
+                entry.count = 1;
+                entry.window_start = now;
+                false
+            } else if entry.count >= guild_limit {
+                true
+            } else {
+                entry.count += 1;
+                false
+            }
+        } else {
+            guild_limits.insert(
+                guild_id.to_string(),
+                RateLimitEntry {
+                    count: 1,
+                    window_start: now,
+                },
+            );
+            false
+        };
+
+        // Check user rate limit
+        let mut user_limits = self.user_limits.write().await;
+        let user_limited = if let Some(entry) = user_limits.get_mut(user_id) {
+            if now - entry.window_start > window_duration {
+                // Reset window
+                entry.count = 1;
+                entry.window_start = now;
+                false
+            } else if entry.count >= user_limit {
+                true
+            } else {
+                entry.count += 1;
+                false
+            }
+        } else {
+            user_limits.insert(
+                user_id.to_string(),
+                RateLimitEntry {
+                    count: 1,
+                    window_start: now,
+                },
+            );
+            false
+        };
+
+        (guild_limited, user_limited)
+    }
+
+    pub async fn cleanup_expired(&self) {
+        let now = Utc::now();
+        let window_duration = Duration::seconds(self.window_seconds);
+
+        let mut guild_limits = self.guild_limits.write().await;
+        guild_limits.retain(|_, entry| now - entry.window_start <= window_duration);
+
+        let mut user_limits = self.user_limits.write().await;
+        user_limits.retain(|_, entry| now - entry.window_start <= window_duration);
+    }
+}

backend_api/src/v1/enums.rs

@@ -0,0 +1,68 @@
+use poem_openapi::Enum;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Serialize, Deserialize, Enum)]
+#[oai(rename_all = "lowercase")]
+pub enum LlmProvider {
+    Anthropic,
+    Ollama,
+    Lmstudio,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Enum)]
+#[oai(rename_all = "lowercase")]
+pub enum SummarizationStyle {
+    /// Brief, concise summary focusing on key points
+    Brief,
+    /// Detailed, comprehensive summary with context
+    Detailed,
+    /// Funny, humorous take on the content
+    Funny,
+    /// Professional, formal business-style summary
+    Professional,
+    /// Technical, focusing on technical details and terminology
+    Technical,
+    /// ELI5 (Explain Like I'm 5) - simple, easy to understand
+    Eli5,
+    /// Bullet points format
+    Bullets,
+    /// Academic style with citations and formal language
+    Academic,
+
+    /// Roast style
+    Roast,
+}
+
+impl SummarizationStyle {
+    pub fn to_system_prompt(&self) -> String {
+        match self {
+            SummarizationStyle::Brief => {
+                "You are a concise summarization assistant. Create brief, to-the-point summaries that capture only the most essential information. Keep it under 3-4 sentences.".to_string()
+            }
+            SummarizationStyle::Detailed => {
+                "You are a comprehensive summarization assistant. Create detailed summaries that include context, nuances, and important details. Organize information logically and ensure nothing significant is missed.".to_string()
+            }
+            SummarizationStyle::Funny => {
+                "You are a humorous summarization assistant. Create entertaining summaries that capture the essence of the content while adding wit, humor, and playful commentary. Make it fun to read while staying accurate.".to_string()
+            }
+            SummarizationStyle::Professional => {
+                "You are a professional business summarization assistant. Create formal, well-structured summaries suitable for corporate environments. Use professional language and focus on actionable insights.".to_string()
+            }
+            SummarizationStyle::Technical => {
+                "You are a technical summarization assistant. Focus on technical details, specifications, methodologies, and precise terminology. Maintain accuracy and include relevant technical context.".to_string()
+            }
+            SummarizationStyle::Eli5 => {
+                "You are an ELI5 (Explain Like I'm 5) summarization assistant. Break down complex topics into simple, easy-to-understand language that anyone can grasp. Use analogies and simple examples.".to_string()
+            }
+            SummarizationStyle::Bullets => {
+                "You are a bullet-point summarization assistant. Create clear, organized summaries using bullet points. Each point should be concise and capture a distinct idea or fact. Use proper formatting with • or - for bullets.".to_string()
+            }
+            SummarizationStyle::Academic => {
+                "You are an academic summarization assistant. Create scholarly summaries with formal language, proper structure, and attention to methodology and evidence. Maintain objectivity and academic rigor.".to_string()
+            }
+            SummarizationStyle::Roast => {
+                "You are a roast summarization assistant. Create humorous summaries that capture the essence of the content while adding wit, dark humor, and harshly criticizing the content. Make it fun to read while staying accurate.".to_string()
+            }
+        }
+    }
+}

backend_api/src/v1/mod.rs

@@ -0,0 +1,78 @@
+pub mod routes;
+pub mod enums;
+pub mod responses;
+
+use std::sync::Arc;
+use crate::config::Config;
+use crate::cache::Cache;
+use crate::database::Database;
+use crate::rate_limiter::RateLimiter;
+use crate::llm::LlmClient;
+use crate::ocr::OcrProcessor;
+use crate::credits::{CreditSystem, create_credit_tables};
+
+pub struct AppState {
+    pub cache: Cache,
+    pub database: Database,
+    pub rate_limiter: RateLimiter,
+    pub llm_client: LlmClient,
+    pub ocr_processor: OcrProcessor,
+    pub credit_system: CreditSystem,
+    pub config: Config,
+}
+
+impl AppState {
+    pub async fn new(config: Config) -> anyhow::Result<Self> {
+        let cache = Cache::new(
+            config.cache.ttl_seconds.unwrap_or(3600),
+            config.cache.max_size.unwrap_or(1000),
+        );
+
+        // Initialize database
+        let database = Database::new(
+            &config.database.url,
+            config.database.db_type.clone(),
+        ).await?;
+
+        // Create credit system tables
+        create_credit_tables(&database.pool()).await?;
+
+        let rate_limiter = RateLimiter::new(
+            config.rate_limiting.window_seconds.unwrap_or(60),
+        );
+
+        let llm_client = LlmClient::new(config.clone());
+        let ocr_processor = OcrProcessor::new();
+
+        // Initialize credit system with bypass users
+        let credit_system = CreditSystem::new(config.credits.bypass_user_ids.clone());
+
+        Ok(Self {
+            cache,
+            database,
+            rate_limiter,
+            llm_client,
+            ocr_processor,
+            credit_system,
+            config,
+        })
+    }
+}
+
+pub fn create_apis(state: Arc<AppState>) -> (
+    routes::SummarizeApi,
+    routes::CacheApi,
+    routes::ModelsApi,
+    routes::OcrApi,
+    routes::HealthApi,
+    routes::CreditsApi,
+) {
+    (
+        routes::SummarizeApi { state: state.clone() },
+        routes::CacheApi { state: state.clone() },
+        routes::ModelsApi { state: state.clone() },
+        routes::OcrApi { state: state.clone() },
+        routes::HealthApi { state: state.clone() },
+        routes::CreditsApi { state },
+    )
+}

backend_api/src/v1/responses.rs

@@ -0,0 +1,42 @@
+use poem_openapi::{ApiResponse, payload::Json};
+use crate::models::*;
+
+#[derive(ApiResponse)]
+pub enum SummarizeResult {
+    #[oai(status = 200)]
+    Ok(Json<SummarizeResponse>),
+    #[oai(status = 400)]
+    Error(Json<ErrorResponse>),
+}
+
+#[derive(ApiResponse)]
+pub enum CacheStatsResult {
+    #[oai(status = 200)]
+    Ok(Json<CacheStats>),
+    #[oai(status = 500)]
+    Error(Json<ErrorResponse>),
+}
+
+#[derive(ApiResponse)]
+pub enum CacheEntriesResult {
+    #[oai(status = 200)]
+    Ok(Json<Vec<CacheEntry>>),
+    #[oai(status = 500)]
+    Error(Json<ErrorResponse>),
+}
+
+#[derive(ApiResponse)]
+pub enum DeleteResult {
+    #[oai(status = 200)]
+    Ok(Json<SuccessResponse>),
+    #[oai(status = 400)]
+    Error(Json<ErrorResponse>),
+}
+
+#[derive(ApiResponse)]
+pub enum OcrSummarizeResult {
+    #[oai(status = 200)]
+    Ok(Json<OcrSummarizeResponse>),
+    #[oai(status = 400)]
+    Error(Json<ErrorResponse>),
+}

backend_api/src/v1/routes/cache.rs

@@ -0,0 +1,135 @@
+use poem_openapi::{payload::Json, param::{Path, Query}, OpenApi};
+use std::sync::Arc;
+use tracing::warn;
+
+use crate::models::{CacheStats, CacheEntry, DeleteCacheRequest, SuccessResponse};
+use super::super::AppState;
+
+pub struct CacheApi {
+    pub state: Arc<AppState>,
+}
+
+#[OpenApi(prefix_path = "/cache")]
+impl CacheApi {
+    /// Get cache statistics from database (persistent stats)
+    #[oai(path = "/stats", method = "get")]
+    pub async fn get_cache_stats(&self) -> Json<CacheStats> {
+        // Get stats from database for accurate persistent statistics
+        match self.state.database.get_cache_stats().await {
+            Ok(stats) => Json(stats),
+            Err(e) => {
+                warn!("Failed to get cache stats from database: {}", e);
+                // Fallback to in-memory stats
+                let (hits, misses, size) = self.state.cache.get_stats().await;
+                Json(CacheStats {
+                    total_entries: size as i64,
+                    total_hits: hits as i64,
+                    total_misses: misses as i64,
+                    hit_rate: if hits + misses > 0 {
+                        (hits as f64 / (hits + misses) as f64) * 100.0
+                    } else {
+                        0.0
+                    },
+                    total_size_bytes: 0,
+                })
+            }
+        }
+    }
+
+    /// List cache entries with pagination from database
+    #[oai(path = "/entries", method = "get")]
+    pub async fn list_cache_entries(
+        &self,
+        limit: Query<Option<i64>>,
+        offset: Query<Option<i64>>,
+    ) -> Json<Vec<CacheEntry>> {
+        // Fetch from database for complete persistent data
+        match self.state.database.get_all_cache_entries(limit.0, offset.0).await {
+            Ok(entries) => Json(entries),
+            Err(e) => {
+                warn!("Failed to list cache entries from database: {}", e);
+                // Fallback to in-memory cache
+                let limit_usize = limit.0.map(|l| l as usize);
+                let offset_usize = offset.0.map(|o| o as usize);
+                let entries = self.state.cache.get_all(limit_usize, offset_usize).await;
+                Json(entries)
+            }
+        }
+    }
+
+    /// Get cache entries for a specific guild from database
+    #[oai(path = "/guild/:guild_id", method = "get")]
+    pub async fn get_guild_cache(
+        &self,
+        guild_id: Path<String>,
+    ) -> Json<Vec<CacheEntry>> {
+        // Fetch from database for complete persistent data
+        match self.state.database.get_cache_by_guild(&guild_id.0).await {
+            Ok(entries) => Json(entries),
+            Err(e) => {
+                warn!("Failed to get guild cache from database: {}", e);
+                // Fallback to in-memory cache
+                let entries = self.state.cache.get_by_guild(&guild_id.0).await;
+                Json(entries)
+            }
+        }
+    }
+
+    /// Get cache entries for a specific user from database
+    #[oai(path = "/user/:user_id", method = "get")]
+    pub async fn get_user_cache(
+        &self,
+        user_id: Path<String>,
+    ) -> Json<Vec<CacheEntry>> {
+        // Fetch from database for complete persistent data
+        match self.state.database.get_cache_by_user(&user_id.0).await {
+            Ok(entries) => Json(entries),
+            Err(e) => {
+                warn!("Failed to get user cache from database: {}", e);
+                // Fallback to in-memory cache
+                let entries = self.state.cache.get_by_user(&user_id.0).await;
+                Json(entries)
+            }
+        }
+    }
+
+    /// Delete cache entries from both memory and database
+    #[oai(path = "/delete", method = "post")]
+    pub async fn delete_cache(
+        &self,
+        request: Json<DeleteCacheRequest>,
+    ) -> Json<SuccessResponse> {
+        let request = request.0;
+
+        // Delete from both memory cache and database
+        let (memory_deleted, db_deleted) = if let Some(id) = request.id {
+            let mem = self.state.cache.delete_by_id(id).await;
+            let db = self.state.database.delete_cache_by_id(id).await.unwrap_or(0);
+            (mem, db)
+        } else if let Some(guild_id) = request.guild_id {
+            let mem = self.state.cache.delete_by_guild(&guild_id).await;
+            let db = self.state.database.delete_cache_by_guild(&guild_id).await.unwrap_or(0);
+            (mem, db)
+        } else if let Some(user_id) = request.user_id {
+            let mem = self.state.cache.delete_by_user(&user_id).await;
+            let db = self.state.database.delete_cache_by_user(&user_id).await.unwrap_or(0);
+            (mem, db)
+        } else if request.delete_all == Some(true) {
+            let mem = self.state.cache.delete_all().await;
+            let db = self.state.database.delete_all_cache().await.unwrap_or(0);
+            (mem, db)
+        } else {
+            (0, 0)
+        };
+
+        let total_deleted = memory_deleted + db_deleted;
+
+        Json(SuccessResponse {
+            success: true,
+            message: format!(
+                "Deleted {} cache entries (memory: {}, database: {})",
+                total_deleted, memory_deleted, db_deleted
+            ),
+        })
+    }
+}

backend_api/src/v1/routes/credits.rs

@@ -0,0 +1,357 @@
+//! Credits API routes for managing user credits and tiers.
+
+use poem_openapi::{param::Path, param::Query, payload::Json, Object, OpenApi, Tags};
+use serde::{Deserialize, Serialize};
+use std::sync::Arc;
+
+use crate::credits::TierLevel;
+use crate::v1::AppState;
+
+#[derive(Tags)]
+enum ApiTags {
+    /// Credit management endpoints
+    Credits,
+}
+
+/// Credits API for managing user credits
+pub struct CreditsApi {
+    pub state: Arc<AppState>,
+}
+
+// ==================== Request/Response Models ====================
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct UserCreditsResponse {
+    pub success: bool,
+    pub user_id: String,
+    pub credits: i64,
+    pub tier_id: i32,
+    pub tier_name: String,
+    pub lifetime_credits_used: i64,
+    pub is_unlimited: bool,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct AddCreditsRequest {
+    pub user_id: String,
+    pub amount: i64,
+    #[oai(default)]
+    pub transaction_type: Option<String>,
+    #[oai(default)]
+    pub description: Option<String>,
+    #[oai(default)]
+    pub guild_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct AddCreditsResponse {
+    pub success: bool,
+    pub user_id: String,
+    pub new_balance: i64,
+    pub amount_added: i64,
+    #[oai(default)]
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct DeductCreditsRequest {
+    pub user_id: String,
+    pub amount: i64,
+    #[oai(default)]
+    pub description: Option<String>,
+    #[oai(default)]
+    pub guild_id: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct DeductCreditsResponse {
+    pub success: bool,
+    pub user_id: String,
+    pub new_balance: i64,
+    pub amount_deducted: i64,
+    #[oai(default)]
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SetTierRequest {
+    pub user_id: String,
+    pub tier_id: i32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SetTierResponse {
+    pub success: bool,
+    pub user_id: String,
+    pub tier_id: i32,
+    pub tier_name: String,
+    #[oai(default)]
+    pub error: Option<String>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct TierInfo {
+    pub id: i32,
+    pub name: String,
+    pub monthly_credits: i64,
+    pub price_usd: f64,
+    pub max_messages_per_summary: i32,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct TiersResponse {
+    pub success: bool,
+    pub tiers: Vec<TierInfo>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct TransactionInfo {
+    pub id: i64,
+    pub user_id: String,
+    pub guild_id: Option<String>,
+    pub amount: i64,
+    pub transaction_type: String,
+    pub description: String,
+    pub balance_after: i64,
+    pub created_at: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct TransactionsResponse {
+    pub success: bool,
+    pub transactions: Vec<TransactionInfo>,
+    #[oai(default)]
+    pub error: Option<String>,
+}
+
+// ==================== API Implementation ====================
+
+#[OpenApi(prefix_path = "/credits", tag = "ApiTags::Credits")]
+impl CreditsApi {
+    /// Get user credits
+    #[oai(path = "/:user_id", method = "get")]
+    pub async fn get_credits(&self, user_id: Path<String>) -> Json<UserCreditsResponse> {
+        let pool = self.state.database.pool();
+
+        match self.state.credit_system.get_or_create_user(pool, &user_id.0).await {
+            Ok(user) => {
+                let tier_name = match user.tier_id {
+                    1 => "free",
+                    2 => "basic",
+                    3 => "pro",
+                    4 => "unlimited",
+                    _ => "free",
+                };
+
+                Json(UserCreditsResponse {
+                    success: true,
+                    user_id: user.user_id,
+                    credits: user.credits,
+                    tier_id: user.tier_id,
+                    tier_name: tier_name.to_string(),
+                    lifetime_credits_used: user.lifetime_credits_used,
+                    is_unlimited: user.tier_id == 4,
+                })
+            }
+            Err(_e) => Json(UserCreditsResponse {
+                success: false,
+                user_id: user_id.0.clone(),
+                credits: 0,
+                tier_id: 1,
+                tier_name: "free".to_string(),
+                lifetime_credits_used: 0,
+                is_unlimited: false,
+            }),
+        }
+    }
+
+    /// Add credits to a user
+    #[oai(path = "/add", method = "post")]
+    pub async fn add_credits(&self, request: Json<AddCreditsRequest>) -> Json<AddCreditsResponse> {
+        let pool = self.state.database.pool();
+        let tx_type = request.transaction_type.as_deref().unwrap_or("add");
+        let description = request.description.as_deref().unwrap_or("Credits added");
+
+        match self.state.credit_system.add_credits(
+            pool,
+            &request.user_id,
+            request.amount,
+            request.guild_id.as_deref(),
+            tx_type,
+            description,
+        ).await {
+            Ok(new_balance) => Json(AddCreditsResponse {
+                success: true,
+                user_id: request.user_id.clone(),
+                new_balance,
+                amount_added: request.amount,
+                error: None,
+            }),
+            Err(e) => Json(AddCreditsResponse {
+                success: false,
+                user_id: request.user_id.clone(),
+                new_balance: 0,
+                amount_added: 0,
+                error: Some(format!("{}", e)),
+            }),
+        }
+    }
+
+    /// Deduct credits from a user
+    #[oai(path = "/deduct", method = "post")]
+    pub async fn deduct_credits(&self, request: Json<DeductCreditsRequest>) -> Json<DeductCreditsResponse> {
+        let pool = self.state.database.pool();
+        let description = request.description.as_deref().unwrap_or("Credits deducted");
+
+        let user = match self.state.credit_system.get_or_create_user(pool, &request.user_id).await {
+            Ok(u) => u,
+            Err(e) => {
+                return Json(DeductCreditsResponse {
+                    success: false,
+                    user_id: request.user_id.clone(),
+                    new_balance: 0,
+                    amount_deducted: 0,
+                    error: Some(format!("Failed to get user: {}", e)),
+                });
+            }
+        };
+
+        if user.tier_id == 4 || self.state.credit_system.is_bypass_user(&request.user_id) {
+            return Json(DeductCreditsResponse {
+                success: true,
+                user_id: request.user_id.clone(),
+                new_balance: user.credits,
+                amount_deducted: 0,
+                error: None,
+            });
+        }
+
+        if user.credits < request.amount {
+            return Json(DeductCreditsResponse {
+                success: false,
+                user_id: request.user_id.clone(),
+                new_balance: user.credits,
+                amount_deducted: 0,
+                error: Some(format!("Insufficient credits. Current balance: {}", user.credits)),
+            });
+        }
+
+        match self.state.credit_system.deduct_credits(
+            pool,
+            &request.user_id,
+            request.amount,
+            request.guild_id.as_deref(),
+            description,
+        ).await {
+            Ok(new_balance) => Json(DeductCreditsResponse {
+                success: true,
+                user_id: request.user_id.clone(),
+                new_balance,
+                amount_deducted: request.amount,
+                error: None,
+            }),
+            Err(e) => Json(DeductCreditsResponse {
+                success: false,
+                user_id: request.user_id.clone(),
+                new_balance: user.credits,
+                amount_deducted: 0,
+                error: Some(format!("{}", e)),
+            }),
+        }
+    }
+
+    /// Set user tier
+    #[oai(path = "/tier", method = "post")]
+    pub async fn set_tier(&self, request: Json<SetTierRequest>) -> Json<SetTierResponse> {
+        let pool = self.state.database.pool();
+
+        let tier = match request.tier_id {
+            1 => TierLevel::Free,
+            2 => TierLevel::Basic,
+            3 => TierLevel::Pro,
+            4 => TierLevel::Unlimited,
+            _ => {
+                return Json(SetTierResponse {
+                    success: false,
+                    user_id: request.user_id.clone(),
+                    tier_id: request.tier_id,
+                    tier_name: "invalid".to_string(),
+                    error: Some("Invalid tier ID. Must be 1-4.".to_string()),
+                });
+            }
+        };
+
+        let tier_name = match request.tier_id {
+            1 => "free",
+            2 => "basic",
+            3 => "pro",
+            4 => "unlimited",
+            _ => "unknown",
+        };
+
+        if let Err(e) = self.state.credit_system.get_or_create_user(pool, &request.user_id).await {
+            return Json(SetTierResponse {
+                success: false,
+                user_id: request.user_id.clone(),
+                tier_id: request.tier_id,
+                tier_name: tier_name.to_string(),
+                error: Some(format!("Failed to get/create user: {}", e)),
+            });
+        }
+
+        match self.state.credit_system.set_user_tier(pool, &request.user_id, tier).await {
+            Ok(_) => Json(SetTierResponse {
+                success: true,
+                user_id: request.user_id.clone(),
+                tier_id: request.tier_id,
+                tier_name: tier_name.to_string(),
+                error: None,
+            }),
+            Err(e) => Json(SetTierResponse {
+                success: false,
+                user_id: request.user_id.clone(),
+                tier_id: request.tier_id,
+                tier_name: tier_name.to_string(),
+                error: Some(format!("{}", e)),
+            }),
+        }
+    }
+
+    /// Get all available tiers
+    #[oai(path = "/tiers", method = "get")]
+    pub async fn get_tiers(&self) -> Json<TiersResponse> {
+        let tiers = vec![
+            TierInfo { id: 1, name: "free".to_string(), monthly_credits: 50, price_usd: 0.0, max_messages_per_summary: 50 },
+            TierInfo { id: 2, name: "basic".to_string(), monthly_credits: 500, price_usd: 4.99, max_messages_per_summary: 100 },
+            TierInfo { id: 3, name: "pro".to_string(), monthly_credits: 2000, price_usd: 9.99, max_messages_per_summary: 250 },
+            TierInfo { id: 4, name: "unlimited".to_string(), monthly_credits: -1, price_usd: 19.99, max_messages_per_summary: 500 },
+        ];
+
+        Json(TiersResponse { success: true, tiers })
+    }
+
+    /// Get user transaction history
+    #[oai(path = "/:user_id/transactions", method = "get")]
+    pub async fn get_transactions(&self, user_id: Path<String>, limit: Query<Option<i64>>) -> Json<TransactionsResponse> {
+        let pool = self.state.database.pool();
+        let limit_val = limit.0.unwrap_or(20);
+
+        match self.state.credit_system.get_transactions(pool, &user_id.0, limit_val).await {
+            Ok(transactions) => {
+                let tx_infos: Vec<TransactionInfo> = transactions.into_iter().map(|tx| TransactionInfo {
+                    id: tx.id,
+                    user_id: tx.user_id,
+                    guild_id: tx.guild_id,
+                    amount: tx.amount,
+                    transaction_type: tx.transaction_type,
+                    description: tx.description,
+                    balance_after: tx.balance_after,
+                    created_at: tx.created_at,
+                }).collect();
+
+                Json(TransactionsResponse { success: true, transactions: tx_infos, error: None })
+            }
+            Err(e) => Json(TransactionsResponse { success: false, transactions: vec![], error: Some(format!("{}", e)) }),
+        }
+    }
+}

backend_api/src/v1/routes/health.rs

@@ -0,0 +1,363 @@
+use poem_openapi::{payload::Json, OpenApi, Object, Tags};
+use std::sync::Arc;
+use serde::{Deserialize, Serialize};
+use reqwest::Client;
+
+use crate::models::SuccessResponse;
+use crate::claude_models::ClaudeModelType;
+use super::super::AppState;
+
+#[derive(Tags)]
+enum ApiTags {
+    /// Health check endpoints
+    Health,
+}
+
+pub struct HealthApi {
+    pub state: Arc<AppState>,
+}
+
+/// Simple health status response for bot health checks
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct SimpleHealthResponse {
+    /// Status string ("healthy" or "unhealthy")
+    pub status: String,
+    /// Version of the API
+    pub version: String,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct HealthCheckResponse {
+    /// Overall health status
+    pub healthy: bool,
+    /// Health check timestamp
+    pub timestamp: String,
+    /// Database health
+    pub database: ServiceHealth,
+    /// Anthropic API health (if configured)
+    pub anthropic: Option<ServiceHealth>,
+    /// Ollama API health (if configured)
+    pub ollama: Option<ServiceHealth>,
+    /// LMStudio API health (if configured)
+    pub lmstudio: Option<ServiceHealth>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, Object)]
+pub struct ServiceHealth {
+    /// Whether the service is available
+    pub available: bool,
+    /// Status message
+    pub message: String,
+    /// Response time in milliseconds
+    pub response_time_ms: Option<u64>,
+    /// Available models (if applicable)
+    pub models: Option<Vec<String>>,
+}
+
+#[OpenApi(prefix_path = "/health", tag = "ApiTags::Health")]
+impl HealthApi {
+    /// Simple health check - returns status for bot startup checks
+    #[oai(path = "/", method = "get")]
+    pub async fn health(&self) -> Json<SimpleHealthResponse> {
+        // Quick check if at least one LLM is available
+        let has_anthropic = self.state.config.anthropic.is_some();
+        let has_ollama = self.state.config.ollama.is_some();
+        let has_lmstudio = self.state.config.lmstudio.is_some();
+        
+        let status = if has_anthropic || has_ollama || has_lmstudio {
+            "healthy"
+        } else {
+            "unhealthy"
+        };
+        
+        Json(SimpleHealthResponse {
+            status: status.to_string(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
+        })
+    }
+
+    /// Comprehensive health check endpoint with detailed service status
+    #[oai(path = "/detailed", method = "get")]
+    pub async fn health_detailed(&self) -> Json<HealthCheckResponse> {
+        let _start_time = std::time::Instant::now();
+
+        // Check Database
+        let database = self.check_database().await;
+
+        // Check Anthropic API if configured
+        let anthropic = if self.state.config.anthropic.is_some() {
+            Some(self.check_anthropic().await)
+        } else {
+            None
+        };
+
+        // Check Ollama API if configured
+        let ollama = if self.state.config.ollama.is_some() {
+            Some(self.check_ollama().await)
+        } else {
+            None
+        };
+
+        // Check LMStudio API if configured
+        let lmstudio = if self.state.config.lmstudio.is_some() {
+            Some(self.check_lmstudio().await)
+        } else {
+            None
+        };
+
+        // Determine overall health
+        let mut healthy = database.available;
+
+        // At least one LLM provider should be available
+        let llm_available = anthropic.as_ref().map(|s| s.available).unwrap_or(false)
+            || ollama.as_ref().map(|s| s.available).unwrap_or(false)
+            || lmstudio.as_ref().map(|s| s.available).unwrap_or(false);
+
+        healthy = healthy && llm_available;
+
+        Json(HealthCheckResponse {
+            healthy,
+            timestamp: chrono::Utc::now().to_rfc3339(),
+            database,
+            anthropic,
+            ollama,
+            lmstudio,
+        })
+    }
+
+    /// Simple health check endpoint (just returns OK)
+    #[oai(path = "/simple", method = "get")]
+    pub async fn health_simple(&self) -> Json<SuccessResponse> {
+        Json(SuccessResponse {
+            success: true,
+            message: "API is healthy".to_string(),
+        })
+    }
+
+    async fn check_database(&self) -> ServiceHealth {
+        let start = std::time::Instant::now();
+
+        match self.state.database.health_check().await {
+            Ok(_) => ServiceHealth {
+                available: true,
+                message: "Database is healthy".to_string(),
+                response_time_ms: Some(start.elapsed().as_millis() as u64),
+                models: None,
+            },
+            Err(e) => ServiceHealth {
+                available: false,
+                message: format!("Database error: {}", e),
+                response_time_ms: Some(start.elapsed().as_millis() as u64),
+                models: None,
+            },
+        }
+    }
+
+    async fn check_anthropic(&self) -> ServiceHealth {
+        let start = std::time::Instant::now();
+
+        let config = match &self.state.config.anthropic {
+            Some(c) => c,
+            None => return ServiceHealth {
+                available: false,
+                message: "Anthropic not configured".to_string(),
+                response_time_ms: None,
+                models: None,
+            },
+        };
+
+        let client = Client::new();
+
+        // Try to make a minimal API call to verify the API key
+        #[derive(serde::Serialize)]
+        struct TestRequest {
+            model: String,
+            max_tokens: u32,
+            messages: Vec<TestMessage>,
+        }
+
+        #[derive(serde::Serialize)]
+        struct TestMessage {
+            role: String,
+            content: String,
+        }
+
+        let test_request = TestRequest {
+            model: "claude-haiku-4-5-20251001".to_string(), // Use cheapest model for health check
+            max_tokens: 10,
+            messages: vec![TestMessage {
+                role: "user".to_string(),
+                content: "Hello".to_string(),
+            }],
+        };
+
+        let response = client
+            .post(format!("{}/messages", config.base_url))
+            .header("x-api-key", &config.api_key)
+            .header("anthropic-version", "2023-06-01")
+            .header("content-type", "application/json")
+            .json(&test_request)
+            .send()
+            .await;
+
+        let response_time = start.elapsed().as_millis() as u64;
+
+        match response {
+            Ok(resp) if resp.status().is_success() => {
+                let models = ClaudeModelType::all_available()
+                    .into_iter()
+                    .map(|m| m.id())
+                    .collect();
+
+                ServiceHealth {
+                    available: true,
+                    message: "Anthropic API is healthy".to_string(),
+                    response_time_ms: Some(response_time),
+                    models: Some(models),
+                }
+            }
+            Ok(resp) => {
+                let status = resp.status();
+                let error_text = resp.text().await.unwrap_or_else(|_| "Unknown error".to_string());
+                ServiceHealth {
+                    available: false,
+                    message: format!("Anthropic API error ({}): {}", status, error_text),
+                    response_time_ms: Some(response_time),
+                    models: None,
+                }
+            }
+            Err(e) => ServiceHealth {
+                available: false,
+                message: format!("Failed to connect to Anthropic API: {}", e),
+                response_time_ms: Some(response_time),
+                models: None,
+            },
+        }
+    }
+
+    async fn check_ollama(&self) -> ServiceHealth {
+        let start = std::time::Instant::now();
+
+        let config = match &self.state.config.ollama {
+            Some(c) => c,
+            None => return ServiceHealth {
+                available: false,
+                message: "Ollama not configured".to_string(),
+                response_time_ms: None,
+                models: None,
+            },
+        };
+
+        let client = Client::new();
+
+        // Try to list models
+        let response = client
+            .get(format!("{}/api/tags", config.base_url))
+            .send()
+            .await;
+
+        let response_time = start.elapsed().as_millis() as u64;
+
+        match response {
+            Ok(resp) if resp.status().is_success() => {
+                #[derive(serde::Deserialize)]
+                struct OllamaListResponse {
+                    models: Vec<OllamaModel>,
+                }
+
+                #[derive(serde::Deserialize)]
+                struct OllamaModel {
+                    name: String,
+                }
+
+                let models_list = resp.json::<OllamaListResponse>().await.ok()
+                    .map(|m| m.models.into_iter().map(|model| model.name).collect());
+
+                ServiceHealth {
+                    available: true,
+                    message: "Ollama API is healthy".to_string(),
+                    response_time_ms: Some(response_time),
+                    models: models_list,
+                }
+            }
+            Ok(resp) => {
+                let status = resp.status();
+                ServiceHealth {
+                    available: false,
+                    message: format!("Ollama API error ({})", status),
+                    response_time_ms: Some(response_time),
+                    models: None,
+                }
+            }
+            Err(e) => ServiceHealth {
+                available: false,
+                message: format!("Failed to connect to Ollama API: {}", e),
+                response_time_ms: Some(response_time),
+                models: None,
+            },
+        }
+    }
+
+    async fn check_lmstudio(&self) -> ServiceHealth {
+        let start = std::time::Instant::now();
+
+        let config = match &self.state.config.lmstudio {
+            Some(c) => c,
+            None => return ServiceHealth {
+                available: false,
+                message: "LMStudio not configured".to_string(),
+                response_time_ms: None,
+                models: None,
+            },
+        };
+
+        let client = Client::new();
+
+        // Try to list models (OpenAI-compatible endpoint)
+        let response = client
+            .get(format!("{}/models", config.base_url))
+            .send()
+            .await;
+
+        let response_time = start.elapsed().as_millis() as u64;
+
+        match response {
+            Ok(resp) if resp.status().is_success() => {
+                #[derive(serde::Deserialize)]
+                struct LmStudioModelsResponse {
+                    data: Vec<LmStudioModel>,
+                }
+
+                #[derive(serde::Deserialize)]
+                struct LmStudioModel {
+                    id: String,
+                }
+
+                let models_list = resp.json::<LmStudioModelsResponse>().await.ok()
+                    .map(|m| m.data.into_iter().map(|model| model.id).collect());
+
+                ServiceHealth {
+                    available: true,
+                    message: "LMStudio API is healthy".to_string(),
+                    response_time_ms: Some(response_time),
+                    models: models_list,
+                }
+            }
+            Ok(resp) => {
+                let status = resp.status();
+                ServiceHealth {
+                    available: false,
+                    message: format!("LMStudio API error ({})", status),
+                    response_time_ms: Some(response_time),
+                    models: None,
+                }
+            }
+            Err(e) => ServiceHealth {
+                available: false,
+                message: format!("Failed to connect to LMStudio API: {}", e),
+                response_time_ms: Some(response_time),
+                models: None,
+            },
+        }
+    }
+}

backend_api/src/v1/routes/mod.rs

@@ -0,0 +1,13 @@
+pub mod summarize;
+pub mod cache;
+pub mod models;
+pub mod ocr;
+pub mod health;
+pub mod credits;
+
+pub use summarize::SummarizeApi;
+pub use cache::CacheApi;
+pub use models::ModelsApi;
+pub use ocr::OcrApi;
+pub use health::HealthApi;
+pub use credits::CreditsApi;

backend_api/src/v1/routes/models.rs

@@ -0,0 +1,40 @@
+use poem_openapi::{payload::Json, OpenApi};
+use std::sync::Arc;
+
+use crate::models::LlmInfo;
+use super::super::AppState;
+
+pub struct ModelsApi {
+    pub state: Arc<AppState>,
+}
+
+#[OpenApi(prefix_path = "/models")]
+impl ModelsApi {
+    /// List available LLM models
+    #[oai(path = "/", method = "get")]
+    pub async fn list_models(&self) -> Json<Vec<LlmInfo>> {
+        let mut models = Vec::new();
+
+        // Add Anthropic models
+        if let Some(ref anthropic_config) = self.state.config.anthropic {
+            models.push(LlmInfo {
+                provider: "anthropic".to_string(),
+                model: anthropic_config.model.clone(),
+                version: None,
+                available: true,
+            });
+        }
+
+        // Add Ollama models
+        if let Some(ref ollama_config) = self.state.config.ollama {
+            models.push(LlmInfo {
+                provider: "ollama".to_string(),
+                model: ollama_config.model.clone(),
+                version: None,
+                available: true,
+            });
+        }
+
+        Json(models)
+    }
+}

backend_api/src/v1/routes/ocr.rs

@@ -0,0 +1,217 @@
+use poem_openapi::{payload::{Json, Binary}, param::Query, OpenApi};
+use std::sync::Arc;
+use std::time::Instant;
+use chrono::Utc;
+use tracing::info;
+use validator::Validate;
+
+use crate::models::*;
+use crate::v1::responses::OcrSummarizeResult;
+use crate::v1::enums::{LlmProvider, SummarizationStyle};
+use crate::checksum;
+use super::super::AppState;
+
+pub struct OcrApi {
+    pub state: Arc<AppState>,
+}
+
+#[OpenApi(prefix_path = "/ocr")]
+impl OcrApi {
+    /// OCR and summarize image (send image as binary in request body, params as query/form)
+    #[oai(path = "/summarize", method = "post")]
+    pub async fn ocr_summarize(
+        &self,
+        provider: Query<String>,
+        guild_id: Query<String>,
+        user_id: Query<String>,
+        channel_id: Query<Option<String>>,
+        model: Query<Option<String>>,
+        temperature: Query<Option<f32>>,
+        max_tokens: Query<Option<u32>>,
+        top_p: Query<Option<f32>>,
+        style: Query<Option<String>>,
+        image: Binary<Vec<u8>>,
+    ) -> OcrSummarizeResult {
+        // Parse provider
+        let provider_enum = match provider.0.to_lowercase().as_str() {
+            "anthropic" => LlmProvider::Anthropic,
+            "ollama" => LlmProvider::Ollama,
+            _ => {
+                return OcrSummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: "Invalid provider. Must be 'anthropic' or 'ollama'".to_string(),
+                }));
+            }
+        };
+        
+        // Parse style if provided
+        let style_enum = if let Some(ref s) = style.0 {
+            match s.to_lowercase().as_str() {
+                "brief" => Some(SummarizationStyle::Brief),
+                "detailed" => Some(SummarizationStyle::Detailed),
+                "funny" => Some(SummarizationStyle::Funny),
+                "professional" => Some(SummarizationStyle::Professional),
+                "technical" => Some(SummarizationStyle::Technical),
+                "eli5" => Some(SummarizationStyle::Eli5),
+                "bullets" => Some(SummarizationStyle::Bullets),
+                "academic" => Some(SummarizationStyle::Academic),
+                _ => None,
+            }
+        } else {
+            None
+        };
+        
+        let params = OcrSummarizeRequest {
+            provider: provider_enum.clone(),
+            model: model.0.clone(),
+            temperature: temperature.0,
+            max_tokens: max_tokens.0,
+            top_p: top_p.0,
+            style: style_enum.clone(),
+            system_prompt: None,
+            guild_id: guild_id.0.clone(),
+            user_id: user_id.0.clone(),
+            channel_id: channel_id.0.clone(),
+        };
+        
+        // Validate request
+        if let Err(e) = params.validate() {
+            return OcrSummarizeResult::Error(Json(ErrorResponse {
+                success: false,
+                error: format!("Validation error: {}", e),
+            }));
+        }
+        
+        let total_start = Instant::now();
+        
+        // Check rate limiting if enabled
+        if self.state.config.rate_limiting.enabled {
+            let (guild_limited, user_limited) = self.state.rate_limiter.check_rate_limit(
+                &params.guild_id,
+                &params.user_id,
+                self.state.config.rate_limiting.guild_rate_limit,
+                self.state.config.rate_limiting.user_rate_limit,
+            ).await;
+            
+            if guild_limited {
+                return OcrSummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: "Guild rate limit exceeded".to_string(),
+                }));
+            }
+            if user_limited {
+                return OcrSummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: "User rate limit exceeded".to_string(),
+                }));
+            }
+        }
+        
+        // Get image data
+        let image_data = image.0;
+        
+        // Perform OCR
+        let (extracted_text, image_info, ocr_time_ms) = match self.state.ocr_processor.extract_text_from_image(&image_data).await {
+            Ok(result) => result,
+            Err(e) => {
+                return OcrSummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: format!("OCR failed: {}", e),
+                }));
+            }
+        };
+        
+        info!("OCR extracted {} characters in {}ms", extracted_text.len(), ocr_time_ms);
+        
+        // Create summarize request from extracted text
+        let summarize_request = SummarizeRequest {
+            text: extracted_text.clone(),
+            provider: params.provider.clone(),
+            model: params.model.clone(),
+            temperature: params.temperature,
+            max_tokens: params.max_tokens,
+            top_p: params.top_p,
+            style: params.style.clone(),
+            system_prompt: params.system_prompt.clone(),
+            guild_id: params.guild_id.clone(),
+            user_id: params.user_id.clone(),
+            channel_id: params.channel_id.clone(),
+        };
+        
+        // Calculate checksum for caching
+        let checksum = checksum::calculate_checksum(&summarize_request);
+        
+        let summarization_start = Instant::now();
+        
+        // Check cache if enabled
+        if self.state.config.cache.enabled {
+            if let Some(cached) = self.state.cache.get(&checksum).await {
+                info!("Cache hit for OCR summary checksum: {}", checksum);
+                let total_time = total_start.elapsed().as_millis() as u64;
+                return OcrSummarizeResult::Ok(Json(OcrSummarizeResponse {
+                    extracted_text,
+                    summary: cached.summary,
+                    model: cached.model,
+                    provider: cached.provider,
+                    from_cache: true,
+                    checksum: cached.checksum,
+                    timestamp: Utc::now().to_rfc3339(),
+                    token_usage: None,
+                    ocr_time_ms,
+                    summarization_time_ms: Some(0),
+                    total_time_ms: total_time,
+                    style_used: params.style.as_ref().map(|s| format!("{:?}", s).to_lowercase()),
+                    image_info,
+                }));
+            }
+        }
+        
+        // Call LLM for summarization
+        match self.state.llm_client.summarize(&summarize_request).await {
+            Ok((summary, model, token_usage)) => {
+                let provider = format!("{:?}", params.provider).to_lowercase();
+                let summarization_time_ms = summarization_start.elapsed().as_millis() as u64;
+                
+                // Store in cache if enabled
+                if self.state.config.cache.enabled {
+                    let cache_entry = CacheEntry {
+                        id: chrono::Utc::now().timestamp(),
+                        checksum: checksum.clone(),
+                        text: extracted_text.clone(),
+                        summary: summary.clone(),
+                        provider: provider.clone(),
+                        model: model.clone(),
+                        guild_id: params.guild_id.clone(),
+                        user_id: params.user_id.clone(),
+                        channel_id: params.channel_id.clone(),
+                        created_at: Utc::now().to_rfc3339(),
+                        last_accessed: Utc::now().to_rfc3339(),
+                        access_count: 1,
+                    };
+                    self.state.cache.insert(checksum.clone(), cache_entry).await;
+                }
+                
+                let total_time = total_start.elapsed().as_millis() as u64;
+                OcrSummarizeResult::Ok(Json(OcrSummarizeResponse {
+                    extracted_text,
+                    summary,
+                    model,
+                    provider,
+                    from_cache: false,
+                    checksum,
+                    timestamp: Utc::now().to_rfc3339(),
+                    token_usage: Some(token_usage),
+                    ocr_time_ms,
+                    summarization_time_ms: Some(summarization_time_ms),
+                    total_time_ms: total_time,
+                    style_used: params.style.as_ref().map(|s| format!("{:?}", s).to_lowercase()),
+                    image_info,
+                }))
+            }
+            Err(e) => OcrSummarizeResult::Error(Json(ErrorResponse {
+                success: false,
+                error: format!("Summarization failed: {}", e),
+            })),
+        }
+    }
+}

backend_api/src/v1/routes/summarize.rs

@@ -0,0 +1,205 @@
+use poem_openapi::{payload::Json, OpenApi};
+use std::sync::Arc;
+use std::time::Instant;
+use chrono::Utc;
+use tracing::info;
+use validator::Validate;
+
+use crate::models::*;
+use crate::v1::responses::SummarizeResult;
+use crate::checksum;
+use super::super::AppState;
+
+pub struct SummarizeApi {
+    pub state: Arc<AppState>,
+}
+
+#[OpenApi(prefix_path = "/summarize")]
+impl SummarizeApi {
+    /// Summarize text using specified LLM provider
+    #[oai(path = "/", method = "post")]
+    pub async fn summarize(
+        &self,
+        request: Json<SummarizeRequest>,
+    ) -> SummarizeResult {
+        let request = request.0;
+        
+        // Validate request
+        if let Err(e) = request.validate() {
+            return SummarizeResult::Error(Json(ErrorResponse {
+                success: false,
+                error: format!("Validation error: {}", e),
+            }));
+        }
+        
+        let start_time = Instant::now();
+
+        // Check credits if enabled
+        let credits_needed = self.state.config.credits.credits_per_summary;
+        if self.state.config.credits.enabled {
+            match self.state.credit_system.check_credits(
+                self.state.database.pool(),
+                &request.user_id,
+                credits_needed,
+            ).await {
+                Ok(result) => {
+                    if !result.allowed {
+                        return SummarizeResult::Error(Json(ErrorResponse {
+                            success: false,
+                            error: result.reason.unwrap_or_else(|| "Insufficient credits".to_string()),
+                        }));
+                    }
+                }
+                Err(e) => {
+                    return SummarizeResult::Error(Json(ErrorResponse {
+                        success: false,
+                        error: format!("Credit check failed: {}", e),
+                    }));
+                }
+            }
+        }
+        
+        // Check rate limiting if enabled
+        if self.state.config.rate_limiting.enabled {
+            let (guild_limited, user_limited) = self.state.rate_limiter.check_rate_limit(
+                &request.guild_id,
+                &request.user_id,
+                self.state.config.rate_limiting.guild_rate_limit,
+                self.state.config.rate_limiting.user_rate_limit,
+            ).await;
+            
+            if guild_limited {
+                return SummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: "Guild rate limit exceeded".to_string(),
+                }));
+            }
+            if user_limited {
+                return SummarizeResult::Error(Json(ErrorResponse {
+                    success: false,
+                    error: "User rate limit exceeded".to_string(),
+                }));
+            }
+        }
+
+        // Calculate checksum for caching
+        let checksum = checksum::calculate_checksum(&request);
+
+        // Check cache if enabled (hybrid: memory first, then database)
+        if self.state.config.cache.enabled {
+            // First check in-memory cache
+            if let Some(cached) = self.state.cache.get(&checksum).await {
+                info!("Memory cache hit for checksum: {}", checksum);
+                let processing_time = start_time.elapsed().as_millis() as u64;
+                return SummarizeResult::Ok(Json(SummarizeResponse {
+                    summary: cached.summary,
+                    model: cached.model,
+                    provider: cached.provider,
+                    from_cache: true,
+                    checksum: cached.checksum,
+                    timestamp: Utc::now().to_rfc3339(),
+                    token_usage: None,
+                    processing_time_ms: Some(processing_time),
+                    style_used: None,
+                }));
+            }
+
+            // If not in memory, check database
+            if let Ok(Some(cached)) = self.state.database.get_cache_by_checksum(&checksum).await {
+                info!("Database cache hit for checksum: {}", checksum);
+                // Add to memory cache for faster future access
+                self.state.cache.insert(checksum.clone(), cached.clone()).await;
+                let processing_time = start_time.elapsed().as_millis() as u64;
+                return SummarizeResult::Ok(Json(SummarizeResponse {
+                    summary: cached.summary,
+                    model: cached.model,
+                    provider: cached.provider,
+                    from_cache: true,
+                    checksum: cached.checksum,
+                    timestamp: Utc::now().to_rfc3339(),
+                    token_usage: None,
+                    processing_time_ms: Some(processing_time),
+                    style_used: None,
+                }));
+            }
+        }
+
+        // Call LLM
+        match self.state.llm_client.summarize(&request).await {
+            Ok((summary, model, token_usage)) => {
+                let provider = format!("{:?}", request.provider).to_lowercase();
+
+                // Deduct credits after successful summarization
+                if self.state.config.credits.enabled {
+                    if let Err(e) = self.state.credit_system.deduct_credits(
+                        self.state.database.pool(),
+                        &request.user_id,
+                        credits_needed,
+                        Some(&request.guild_id),
+                        &format!("Summarization ({})", provider),
+                    ).await {
+                        tracing::warn!("Failed to deduct credits: {}", e);
+                    }
+                }
+
+                // Store in cache if enabled (hybrid: both memory and database)
+                if self.state.config.cache.enabled {
+                    // Store in database first
+                    let db_result = self.state.database.insert_cache(
+                        &checksum,
+                        &request.text,
+                        &summary,
+                        &provider,
+                        &model,
+                        &request.guild_id,
+                        &request.user_id,
+                        request.channel_id.as_deref(),
+                        request.temperature,
+                        request.max_tokens,
+                        request.top_p,
+                        request.system_prompt.as_deref(),
+                    ).await;
+
+                    let entry_id = db_result.unwrap_or_else(|e| {
+                        tracing::warn!("Failed to store in database: {}", e);
+                        chrono::Utc::now().timestamp()
+                    });
+
+                    // Also store in memory cache
+                    let cache_entry = CacheEntry {
+                        id: entry_id,
+                        checksum: checksum.clone(),
+                        text: request.text.clone(),
+                        summary: summary.clone(),
+                        provider: provider.clone(),
+                        model: model.clone(),
+                        guild_id: request.guild_id.clone(),
+                        user_id: request.user_id.clone(),
+                        channel_id: request.channel_id.clone(),
+                        created_at: Utc::now().to_rfc3339(),
+                        last_accessed: Utc::now().to_rfc3339(),
+                        access_count: 1,
+                    };
+                    self.state.cache.insert(checksum.clone(), cache_entry).await;
+                }
+
+                let processing_time = start_time.elapsed().as_millis() as u64;
+                SummarizeResult::Ok(Json(SummarizeResponse {
+                    summary,
+                    model,
+                    provider,
+                    from_cache: false,
+                    checksum,
+                    timestamp: Utc::now().to_rfc3339(),
+                    token_usage: Some(token_usage),
+                    processing_time_ms: Some(processing_time),
+                    style_used: request.style.as_ref().map(|s| format!("{:?}", s).to_lowercase()),
+                }))
+            }
+            Err(e) => SummarizeResult::Error(Json(ErrorResponse {
+                success: false,
+                error: format!("LLM error: {}", e),
+            })),
+        }
+    }
+}

discord_bot/.python-version

@@ -0,0 +1 @@
+3.12

discord_bot/config/config.toml.example

@@ -0,0 +1,28 @@
+[Bot]
+# Discord bot token from https://discord.com/developers/applications
+token = "YOUR_BOT_TOKEN_HERE"
+
+# Discord application ID
+application_id = "YOUR_APPLICATION_ID_HERE"
+
+# Discord user IDs of bot owners (can use admin commands)
+owner_ids = ["YOUR_USER_ID_HERE"]
+
+# Logging configuration
+log_level = "INFO"
+log_format = "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>"
+
+# HTTP client settings
+http_timeout = 30.0
+max_retries = 3
+
+# Command prefix for text commands (slash commands don't need this)
+command_prefix = ["s!", "S!"]
+
+# Debug mode (enables verbose logging)
+debug = false
+
+# Backend API URL (the Rust summarizer API)
+# Must include the full path to the API version, e.g., /api/v1/
+api_url = "http://127.0.0.1:3001/api/v1/"
+

discord_bot/pyproject.toml

@@ -0,0 +1,100 @@
+[project]
+name = "discord-bot"
+version = "0.1.0"
+description = "Discord Summarizer Bot with credit-based monetization"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "attrs==25.4.0",
+    "disnake==2.11.0",
+    "httpx==0.28.1",
+    "loguru==0.7.3",
+    "pydantic==2.12.3",
+]
+
+[dependency-groups]
+dev = [
+    "black==25.9.0",
+    "isort==7.0.0",
+    "pyright==1.1.407",
+    "ruff==0.14.3",
+]
+
+[tool.black]
+line-length = 88
+target-version = ["py312"]
+
+[tool.ruff.isort]
+combine-as-imports = true
+
+[tool.slotscheck]
+strict-imports = true
+require-superclass = true
+require-subclass = false
+
+[tool.pyright]
+typeCheckingMode = "strict"
+pythonVersion = "3.12"
+
+[tool.ruff]
+select = [
+    "E",
+    "F",
+    "W",
+    "I",
+    "D",
+    "UP",
+    "YTT",
+    "ANN",
+    "S",
+    "BLE",
+    "FBT",
+    "B",
+    "C4",
+    "DTZ",
+    "T10",
+    "EM",
+    "ISC",
+    "G",
+    "PIE",
+    "T20",
+    "Q",
+    "RSE",
+    "RET",
+    "SIM",
+    "ARG",
+    "PGH",
+    "PLC",
+    "PLE",
+    "PLR",
+    "PLW",
+    "TRY",
+    "RUF",
+]
+
+ignore = [
+    "F403",
+    "F405",
+    "D107",
+    "D203",
+    "D213",
+    "RET505",
+    "RET506",
+    "RET507",
+    "RET508",
+    "PLR2004",
+    "PLR0912",
+    "PLR0913",
+    "PLR0915",
+    "UP006",
+    "UP007",
+    "UP035",
+    "S311",
+]
+unfixable = ["RET502", "RET503"]
+
+[tool.ruff.pydocstyle]
+convention = "numpy"
+
+[tool.ruff.per-file-ignores]
+"__init__.py" = ["F401"]

discord_bot/sdk/__init__.py

@@ -0,0 +1,69 @@
+"""Summarizer API Python SDK.
+
+A fully typed async client for the Summarizer API.
+
+Usage:
+    from sdk import SummarizerClient, LlmProvider
+
+    async with SummarizerClient() as client:
+        response = await client.summarize(
+            text="Long text to summarize...",
+            provider=LlmProvider.ANTHROPIC,
+            guild_id="123456789",
+            user_id="987654321",
+        )
+        print(response.summary)
+"""
+
+from .client import SummarizerClient
+from .exceptions import (
+    SummarizerAPIError,
+    SummarizerBadRequestError,
+    SummarizerConnectionError,
+    SummarizerRateLimitError,
+    SummarizerServerError,
+    SummarizerTimeoutError,
+)
+from .models import (
+    CacheEntry,
+    CacheStats,
+    DeleteCacheRequest,
+    ErrorResponse,
+    ImageInfo,
+    LlmInfo,
+    LlmProvider,
+    OcrSummarizeResponse,
+    SuccessResponse,
+    SummarizationStyle,
+    SummarizeRequest,
+    SummarizeResponse,
+    TokenUsage,
+)
+
+__all__ = [
+    # Client
+    "SummarizerClient",
+    # Exceptions
+    "SummarizerAPIError",
+    "SummarizerBadRequestError",
+    "SummarizerConnectionError",
+    "SummarizerRateLimitError",
+    "SummarizerServerError",
+    "SummarizerTimeoutError",
+    # Enums
+    "LlmProvider",
+    "SummarizationStyle",
+    # Request models
+    "SummarizeRequest",
+    "DeleteCacheRequest",
+    # Response models
+    "SummarizeResponse",
+    "OcrSummarizeResponse",
+    "CacheEntry",
+    "CacheStats",
+    "LlmInfo",
+    "SuccessResponse",
+    "ErrorResponse",
+    "TokenUsage",
+    "ImageInfo",
+]

discord_bot/sdk/client.py

@@ -0,0 +1,374 @@
+"""Async client for the Summarizer API."""
+from __future__ import annotations
+
+from types import TracebackType
+from typing import Any, Self
+
+import httpx
+
+from .exceptions import (
+    SummarizerAPIError,
+    SummarizerBadRequestError,
+    SummarizerConnectionError,
+    SummarizerRateLimitError,
+    SummarizerServerError,
+    SummarizerTimeoutError,
+)
+from .models import (
+    CacheEntry,
+    CacheStats,
+    DeleteCacheRequest,
+    ErrorResponse,
+    HealthResponse,
+    LlmInfo,
+    LlmProvider,
+    OcrSummarizeResponse,
+    SuccessResponse,
+    SummarizationStyle,
+    SummarizeRequest,
+    SummarizeResponse,
+)
+
+DEFAULT_BASE_URL = "http://127.0.0.1:3001/api"
+DEFAULT_TIMEOUT = 60.0
+
+
+class SummarizerClient:
+    """Async client for the Summarizer API.
+
+    Usage:
+        async with SummarizerClient() as client:
+            response = await client.summarize(
+                text="Long text to summarize...",
+                provider=LlmProvider.ANTHROPIC,
+                guild_id="123456789",
+                user_id="987654321",
+            )
+            print(response.summary)
+    """
+
+    def __init__(
+        self,
+        base_url: str = DEFAULT_BASE_URL,
+        timeout: float = DEFAULT_TIMEOUT,
+        headers: dict[str, str] | None = None,
+    ) -> None:
+        """Initialize the client.
+
+        Args:
+            base_url: Base URL for the API (default: http://127.0.0.1:3001/api)
+            timeout: Request timeout in seconds (default: 60.0)
+            headers: Additional headers to include in requests
+        """
+        self._base_url = base_url.rstrip("/")
+        self._timeout = timeout
+        self._headers = headers or {}
+        self._client: httpx.AsyncClient | None = None
+
+    async def __aenter__(self) -> Self:
+        """Enter async context manager and create HTTP session."""
+        self._client = httpx.AsyncClient(
+            base_url=self._base_url,
+            timeout=self._timeout,
+            headers=self._headers,
+        )
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
+        """Exit async context manager and close HTTP session."""
+        if self._client:
+            await self._client.aclose()
+            self._client = None
+
+    def _ensure_client(self) -> httpx.AsyncClient:
+        """Ensure client is initialized."""
+        if self._client is None:
+            msg = (
+                "Client not initialized. Use 'async with SummarizerClient() as client:'"
+            )
+            raise RuntimeError(msg)
+        return self._client
+
+    async def _handle_response(self, response: httpx.Response) -> httpx.Response:
+        """Handle HTTP response and raise appropriate exceptions."""
+        if response.status_code == 200:
+            return response
+
+        try:
+            error_data = response.json()
+            error_response = ErrorResponse.model_validate(error_data)
+            error_message = error_response.error
+        except Exception:  # noqa: BLE001
+            error_message = response.text or f"HTTP {response.status_code}"
+
+        if response.status_code == 400:
+            raise SummarizerBadRequestError(error_message, response)
+        if response.status_code == 429:
+            raise SummarizerRateLimitError(error_message)
+        if response.status_code >= 500:
+            raise SummarizerServerError(error_message, response.status_code)
+
+        raise SummarizerAPIError(error_message, response.status_code)
+
+    async def _request(
+        self,
+        method: str,
+        path: str,
+        *,
+        json: dict[str, Any] | None = None,
+        params: dict[str, str | int | float] | None = None,
+        content: bytes | None = None,
+        content_type: str | None = None,
+    ) -> httpx.Response:
+        """Make an HTTP request."""
+        client = self._ensure_client()
+
+        headers: dict[str, str] = {}
+        if content_type:
+            headers["Content-Type"] = content_type
+
+        try:
+            response = await client.request(
+                method,
+                path,
+                json=json,
+                params=params,
+                content=content,
+                headers=headers if headers else None,
+            )
+            return await self._handle_response(response)
+        except httpx.ConnectError as e:
+            raise SummarizerConnectionError(str(e)) from e
+        except httpx.TimeoutException as e:
+            raise SummarizerTimeoutError(str(e)) from e
+        except httpx.HTTPError as e:
+            raise SummarizerAPIError(str(e)) from e
+
+    async def summarize(
+        self,
+        text: str,
+        provider: LlmProvider,
+        guild_id: str,
+        user_id: str,
+        *,
+        model: str | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        top_p: float | None = None,
+        style: SummarizationStyle | None = None,
+        system_prompt: str | None = None,
+        channel_id: str | None = None,
+    ) -> SummarizeResponse:
+        """Summarize text using the specified LLM provider.
+
+        Args:
+            text: The text to summarize
+            provider: LLM provider (anthropic, ollama, or lmstudio)
+            guild_id: Discord guild ID
+            user_id: Discord user ID
+            model: Model name (optional, uses default from config)
+            temperature: Temperature (0.0 to 2.0)
+            max_tokens: Max tokens for the response
+            top_p: Top P sampling (0.0 to 1.0)
+            style: Predefined summarization style
+            system_prompt: Custom system prompt (ignored if style is set)
+            channel_id: Discord channel ID
+
+        Returns:
+            SummarizeResponse with the generated summary
+        """
+        request = SummarizeRequest(
+            text=text,
+            provider=provider,
+            guild_id=guild_id,
+            user_id=user_id,
+            model=model,
+            temperature=temperature,
+            max_tokens=max_tokens,
+            top_p=top_p,
+            style=style,
+            system_prompt=system_prompt,
+            channel_id=channel_id,
+        )
+
+        response = await self._request(
+            "POST",
+            "/summarize",
+            json=request.model_dump(exclude_none=True),
+        )
+        return SummarizeResponse.model_validate(response.json())
+
+    async def ocr_summarize(
+        self,
+        image_data: bytes,
+        provider: LlmProvider,
+        guild_id: str,
+        user_id: str,
+        *,
+        model: str | None = None,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        top_p: float | None = None,
+        style: SummarizationStyle | None = None,
+        channel_id: str | None = None,
+    ) -> OcrSummarizeResponse:
+        """OCR and summarize an image.
+
+        Args:
+            image_data: Raw image bytes
+            provider: LLM provider
+            guild_id: Discord guild ID
+            user_id: Discord user ID
+            model: Model name (optional)
+            temperature: Temperature (0.0 to 2.0)
+            max_tokens: Max tokens for the response
+            top_p: Top P sampling (0.0 to 1.0)
+            style: Predefined summarization style
+            channel_id: Discord channel ID
+
+        Returns:
+            OcrSummarizeResponse with extracted text and summary
+        """
+        params: dict[str, str | int | float] = {
+            "provider": provider.value,
+            "guild_id": guild_id,
+            "user_id": user_id,
+        }
+        if model is not None:
+            params["model"] = model
+        if temperature is not None:
+            params["temperature"] = temperature
+        if max_tokens is not None:
+            params["max_tokens"] = max_tokens
+        if top_p is not None:
+            params["top_p"] = top_p
+        if style is not None:
+            params["style"] = style.value
+        if channel_id is not None:
+            params["channel_id"] = channel_id
+
+        response = await self._request(
+            "POST",
+            "/ocr-summarize",
+            params=params,
+            content=image_data,
+            content_type="application/octet-stream",
+        )
+        return OcrSummarizeResponse.model_validate(response.json())
+
+    async def list_models(self) -> list[LlmInfo]:
+        """List available LLM models.
+
+        Returns:
+            List of available LLM models
+        """
+        response = await self._request("GET", "/models")
+        data = response.json()
+        return [LlmInfo.model_validate(item) for item in data]
+
+    async def get_cache_stats(self) -> CacheStats:
+        """Get cache statistics.
+
+        Returns:
+            CacheStats with cache metrics
+        """
+        response = await self._request("GET", "/cache/stats")
+        return CacheStats.model_validate(response.json())
+
+    async def list_cache_entries(
+        self,
+        *,
+        limit: int | None = None,
+        offset: int | None = None,
+    ) -> list[CacheEntry]:
+        """List cache entries with pagination.
+
+        Args:
+            limit: Maximum number of entries to return
+            offset: Number of entries to skip
+
+        Returns:
+            List of cache entries
+        """
+        params: dict[str, str | int | float] = {}
+        if limit is not None:
+            params["limit"] = limit
+        if offset is not None:
+            params["offset"] = offset
+
+        response = await self._request("GET", "/cache/entries", params=params)
+        data = response.json()
+        return [CacheEntry.model_validate(item) for item in data]
+
+    async def get_guild_cache(self, guild_id: str) -> list[CacheEntry]:
+        """Get cache entries for a specific guild.
+
+        Args:
+            guild_id: Discord guild ID
+
+        Returns:
+            List of cache entries for the guild
+        """
+        response = await self._request("GET", f"/cache/guild/{guild_id}")
+        data = response.json()
+        return [CacheEntry.model_validate(item) for item in data]
+
+    async def get_user_cache(self, user_id: str) -> list[CacheEntry]:
+        """Get cache entries for a specific user.
+
+        Args:
+            user_id: Discord user ID
+
+        Returns:
+            List of cache entries for the user
+        """
+        response = await self._request("GET", f"/cache/user/{user_id}")
+        data = response.json()
+        return [CacheEntry.model_validate(item) for item in data]
+
+    async def delete_cache(
+        self,
+        *,
+        entry_id: int | None = None,
+        guild_id: str | None = None,
+        user_id: str | None = None,
+        delete_all: bool = False,
+    ) -> SuccessResponse:
+        """Delete cache entries.
+
+        Args:
+            entry_id: Specific cache entry ID to delete
+            guild_id: Delete all entries for a guild
+            user_id: Delete all entries for a user
+            delete_all: Delete all entries (use with caution)
+
+        Returns:
+            SuccessResponse confirming deletion
+        """
+        request = DeleteCacheRequest(
+            id=entry_id,
+            guild_id=guild_id,
+            user_id=user_id,
+            delete_all=delete_all if delete_all else None,
+        )
+
+        response = await self._request(
+            "POST",
+            "/cache/delete",
+            json=request.model_dump(exclude_none=True),
+        )
+        return SuccessResponse.model_validate(response.json())
+
+    async def health_check(self) -> HealthResponse:
+        """Check API health.
+
+        Returns:
+            HealthResponse with status and version
+        """
+        response = await self._request("GET", "/health")
+        return HealthResponse.model_validate(response.json())

discord_bot/sdk/exceptions.py

@@ -0,0 +1,57 @@
+"""Exception classes for Summarizer API errors."""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from httpx import Response
+
+
+class SummarizerAPIError(Exception):
+    """Base exception for Summarizer API errors."""
+
+    def __init__(self, message: str, status_code: int | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+    def __str__(self) -> str:
+        if self.status_code:
+            return f"[{self.status_code}] {self.message}"
+        return self.message
+
+
+class SummarizerConnectionError(SummarizerAPIError):
+    """Raised when connection to the API fails."""
+
+    def __init__(self, message: str = "Failed to connect to Summarizer API") -> None:
+        super().__init__(message)
+
+
+class SummarizerTimeoutError(SummarizerAPIError):
+    """Raised when API request times out."""
+
+    def __init__(self, message: str = "Request to Summarizer API timed out") -> None:
+        super().__init__(message)
+
+
+class SummarizerBadRequestError(SummarizerAPIError):
+    """Raised for 400 Bad Request errors."""
+
+    def __init__(self, message: str, response: Response | None = None) -> None:
+        super().__init__(message, status_code=400)
+        self.response = response
+
+
+class SummarizerServerError(SummarizerAPIError):
+    """Raised for 5xx server errors."""
+
+    def __init__(self, message: str, status_code: int = 500) -> None:
+        super().__init__(message, status_code=status_code)
+
+
+class SummarizerRateLimitError(SummarizerAPIError):
+    """Raised when rate limit is exceeded."""
+
+    def __init__(self, message: str = "Rate limit exceeded") -> None:
+        super().__init__(message, status_code=429)

discord_bot/sdk/models.py

@@ -0,0 +1,213 @@
+"""Models for Summarizer API."""
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Annotated
+
+from pydantic import BaseModel, Field
+
+
+class LlmProvider(StrEnum):
+    """LLM provider options."""
+
+    ANTHROPIC = "anthropic"
+    OLLAMA = "ollama"
+    LMSTUDIO = "lmstudio"
+
+
+class SummarizationStyle(StrEnum):
+    """Predefined summarization styles."""
+
+    BRIEF = "brief"
+    DETAILED = "detailed"
+    FUNNY = "funny"
+    PROFESSIONAL = "professional"
+    TECHNICAL = "technical"
+    ELI5 = "eli5"
+    BULLETS = "bullets"
+    ACADEMIC = "academic"
+    ROAST = "roast"
+
+
+class TokenUsage(BaseModel):
+    """Token usage information from LLM response."""
+
+    input_tokens: Annotated[int, Field(description="Input tokens (prompt)")]
+    output_tokens: Annotated[int, Field(description="Output tokens (completion)")]
+    total_tokens: Annotated[int, Field(description="Total tokens used")]
+    estimated_cost_usd: Annotated[
+        float | None, Field(default=None, description="Estimated cost in USD")
+    ]
+
+
+class ImageInfo(BaseModel):
+    """Image metadata from OCR processing."""
+
+    width: Annotated[int, Field(description="Image width in pixels")]
+    height: Annotated[int, Field(description="Image height in pixels")]
+    format: Annotated[str, Field(description="Image format (e.g., PNG, JPEG)")]
+    size_bytes: Annotated[int, Field(description="File size in bytes")]
+
+
+class SummarizeRequest(BaseModel):
+    """Request payload for text summarization."""
+
+    text: Annotated[
+        str, Field(min_length=1, max_length=100000, description="Text to summarize")
+    ]
+    provider: Annotated[LlmProvider, Field(description="LLM provider")]
+    guild_id: Annotated[
+        str, Field(min_length=1, max_length=50, description="Discord guild ID")
+    ]
+    user_id: Annotated[
+        str, Field(min_length=1, max_length=50, description="Discord user ID")
+    ]
+    model: Annotated[
+        str | None, Field(default=None, max_length=100, description="Model name")
+    ]
+    temperature: Annotated[
+        float | None,
+        Field(default=None, ge=0.0, le=2.0, description="Temperature (0.0 to 2.0)"),
+    ]
+    max_tokens: Annotated[
+        int | None,
+        Field(default=None, ge=1, le=100000, description="Max tokens for response"),
+    ]
+    top_p: Annotated[
+        float | None,
+        Field(default=None, ge=0.0, le=1.0, description="Top P sampling (0.0 to 1.0)"),
+    ]
+    style: Annotated[
+        SummarizationStyle | None,
+        Field(default=None, description="Summarization style"),
+    ]
+    system_prompt: Annotated[
+        str | None,
+        Field(default=None, max_length=5000, description="Custom system prompt"),
+    ]
+    channel_id: Annotated[
+        str | None, Field(default=None, max_length=50, description="Discord channel ID")
+    ]
+
+
+class SummarizeResponse(BaseModel):
+    """Response from text summarization endpoint."""
+
+    summary: Annotated[str, Field(description="Generated summary")]
+    model: Annotated[str, Field(description="Model used")]
+    provider: Annotated[str, Field(description="Provider used")]
+    from_cache: Annotated[bool, Field(description="Whether served from cache")]
+    checksum: Annotated[str, Field(description="Request checksum")]
+    timestamp: Annotated[str, Field(description="Timestamp")]
+    token_usage: Annotated[
+        TokenUsage | None, Field(default=None, description="Token usage info")
+    ]
+    processing_time_ms: Annotated[
+        int | None, Field(default=None, description="Processing time in milliseconds")
+    ]
+    style_used: Annotated[
+        str | None, Field(default=None, description="Summarization style used")
+    ]
+
+
+class OcrSummarizeResponse(BaseModel):
+    """Response from OCR summarization endpoint."""
+
+    extracted_text: Annotated[str, Field(description="Extracted text from OCR")]
+    summary: Annotated[str, Field(description="Generated summary")]
+    model: Annotated[str, Field(description="Model used")]
+    provider: Annotated[str, Field(description="Provider used")]
+    from_cache: Annotated[bool, Field(description="Whether served from cache")]
+    checksum: Annotated[str, Field(description="Request checksum")]
+    timestamp: Annotated[str, Field(description="Timestamp")]
+    token_usage: Annotated[
+        TokenUsage | None, Field(default=None, description="Token usage info")
+    ]
+    ocr_time_ms: Annotated[
+        int, Field(description="OCR processing time in milliseconds")
+    ]
+    summarization_time_ms: Annotated[
+        int | None,
+        Field(default=None, description="Summarization time in milliseconds"),
+    ]
+    total_time_ms: Annotated[
+        int, Field(description="Total processing time in milliseconds")
+    ]
+    style_used: Annotated[
+        str | None, Field(default=None, description="Summarization style used")
+    ]
+    image_info: Annotated[ImageInfo, Field(description="Image metadata")]
+
+
+class LlmInfo(BaseModel):
+    """Information about an available LLM model."""
+
+    provider: Annotated[str, Field(description="Provider name")]
+    model: Annotated[str, Field(description="Model name")]
+    version: Annotated[str | None, Field(default=None, description="Model version")]
+    available: Annotated[bool, Field(description="Whether model is available")]
+
+
+class CacheEntry(BaseModel):
+    """A single cache entry."""
+
+    id: Annotated[int, Field(description="Cache entry ID")]
+    checksum: Annotated[str, Field(description="Request checksum")]
+    text: Annotated[str, Field(description="Original text")]
+    summary: Annotated[str, Field(description="Generated summary")]
+    provider: Annotated[str, Field(description="Provider used")]
+    model: Annotated[str, Field(description="Model used")]
+    guild_id: Annotated[str, Field(description="Guild ID")]
+    user_id: Annotated[str, Field(description="User ID")]
+    channel_id: Annotated[str | None, Field(default=None, description="Channel ID")]
+    created_at: Annotated[str, Field(description="Created timestamp")]
+    last_accessed: Annotated[str, Field(description="Last accessed timestamp")]
+    access_count: Annotated[int, Field(description="Access count")]
+
+
+class CacheStats(BaseModel):
+    """Cache statistics."""
+
+    total_entries: Annotated[int, Field(description="Total cache entries")]
+    total_hits: Annotated[int, Field(description="Total cache hits")]
+    total_misses: Annotated[int, Field(description="Total cache misses")]
+    hit_rate: Annotated[float, Field(description="Cache hit rate (percentage)")]
+    total_size_bytes: Annotated[int, Field(description="Total size in bytes")]
+
+
+class DeleteCacheRequest(BaseModel):
+    """Request payload for deleting cache entries."""
+
+    id: Annotated[
+        int | None, Field(default=None, description="Cache entry ID to delete")
+    ]
+    guild_id: Annotated[
+        str | None, Field(default=None, description="Delete all for guild")
+    ]
+    user_id: Annotated[
+        str | None, Field(default=None, description="Delete all for user")
+    ]
+    delete_all: Annotated[
+        bool | None, Field(default=None, description="Delete all entries")
+    ]
+
+
+class HealthResponse(BaseModel):
+    """Health check response."""
+
+    status: Annotated[str, Field(description="Health status (e.g., 'healthy')")]
+    version: Annotated[str, Field(description="API version")]
+
+
+class SuccessResponse(BaseModel):
+    """Generic success response."""
+
+    success: Annotated[bool, Field(description="Operation success status")]
+    message: Annotated[str, Field(description="Success message")]
+
+
+class ErrorResponse(BaseModel):
+    """Error response from API."""
+
+    success: Annotated[bool, Field(description="Always False for errors")]
+    error: Annotated[str, Field(description="Error message")]

discord_bot/src/__init__.py

@@ -0,0 +1 @@
+"""Discord bot source package."""

discord_bot/src/bot.py

@@ -0,0 +1,235 @@
+"""Main Discord bot class and entry point."""
+
+from __future__ import annotations
+
+import asyncio
+import pkgutil
+import platform
+import sys
+from datetime import UTC, datetime
+from pathlib import Path
+
+import disnake
+from disnake.ext import commands
+from loguru import logger
+
+from sdk.client import SummarizerClient
+from sdk.exceptions import SummarizerAPIError, SummarizerConnectionError
+from src.config import Config, load_config
+
+# Version info
+__version__ = "1.0.0"
+
+
+class SummarizerBot(commands.InteractionBot):
+    """Summarizer Discord bot with slash commands."""
+
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+        intents = disnake.Intents.default()
+
+        super().__init__(
+            intents=intents,
+            test_guilds=None,  # Use global commands
+            owner_ids={int(uid) for uid in config.bot.owner_ids},
+        )
+
+        self._setup_logging()
+
+    def _setup_logging(self) -> None:
+        """Configure loguru logging with file rotation and formatting."""
+        log_dir = Path(__file__).parent.parent / "logs"
+        log_dir.mkdir(exist_ok=True)
+
+        logger.remove()
+
+        # Console handler with colors
+        logger.add(
+            sys.stderr,
+            format=self.config.bot.log_format,
+            level=self.config.bot.log_level,
+            colorize=True,
+            backtrace=True,
+            diagnose=self.config.bot.debug,
+        )
+
+        # Main log file with rotation
+        logger.add(
+            log_dir / "bot.log",
+            rotation="10 MB",
+            retention="7 days",
+            compression="gz",
+            level="DEBUG" if self.config.bot.debug else "INFO",
+            format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+            backtrace=True,
+            diagnose=True,
+        )
+
+        # Error log file (errors only)
+        logger.add(
+            log_dir / "errors.log",
+            rotation="5 MB",
+            retention="30 days",
+            compression="gz",
+            level="ERROR",
+            format="{time:YYYY-MM-DD HH:mm:ss.SSS} | {level: <8} | {name}:{function}:{line} - {message}",
+            backtrace=True,
+            diagnose=True,
+        )
+
+        logger.debug("Logging initialized")
+
+    async def on_ready(self) -> None:
+        """Called when bot is ready - display startup banner."""
+        self._print_startup_banner()
+
+    def _print_startup_banner(self) -> None:
+        """Print a startup banner with bot information."""
+        total_users = sum(g.member_count or 0 for g in self.guilds)
+        total_channels = sum(len(g.channels) for g in self.guilds)
+
+        banner = f"""
+╔══════════════════════════════════════════════════════════════════╗
+║                                                                  ║
+║   ███████╗██╗   ██╗███╗   ███╗███╗   ███╗ █████╗ ██████╗ ██╗   ██║
+║   ██╔════╝██║   ██║████╗ ████║████╗ ████║██╔══██╗██╔══██╗╚██╗ ██╔║
+║   ███████╗██║   ██║██╔████╔██║██╔████╔██║███████║██████╔╝ ╚████╔╝║
+║   ╚════██║██║   ██║██║╚██╔╝██║██║╚██╔╝██║██╔══██║██╔══██╗  ╚██╔╝ ║
+║   ███████║╚██████╔╝██║ ╚═╝ ██║██║ ╚═╝ ██║██║  ██║██║  ██║   ██║  ║
+║   ╚══════╝ ╚═════╝ ╚═╝     ╚═╝╚═╝     ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝   ╚═╝  ║
+║                        SUMMARIZER BOT                            ║
+║                                                                  ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Bot Information                                                 ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Bot User    : {self.user!s:<49}║
+║  Bot ID      : {self.user.id if self.user else 'N/A'!s:<49}║
+║  Version     : {__version__:<49}║
+║  disnake     : {disnake.__version__:<49}║
+║  Python      : {platform.python_version():<49}║
+╠══════════════════════════════════════════════════════════════════╣
+║  Statistics                                                      ║
+╠══════════════════════════════════════════════════════════════════╣
+║  Guilds      : {len(self.guilds):<49}║
+║  Users       : {total_users:<49}║
+║  Channels    : {total_channels:<49}║
+║  Commands    : {len(self.all_slash_commands):<49}║
+╠══════════════════════════════════════════════════════════════════╣
+║  Configuration                                                   ║
+╠══════════════════════════════════════════════════════════════════╣
+║  API URL     : {self.config.bot.api_url:<49}║
+║  Log Level   : {self.config.bot.log_level:<49}║
+║  Debug Mode  : {self.config.bot.debug!s:<49}║
+╠══════════════════════════════════════════════════════════════════╣
+║  Started at  : {datetime.now(UTC).strftime('%Y-%m-%d %H:%M:%S UTC'):<49}║
+╚══════════════════════════════════════════════════════════════════╝
+"""
+        # Print to console (bypass loguru for clean banner)
+        print(banner)
+
+        # Also log key info
+        logger.info(
+            f"Bot ready: {self.user} (ID: {self.user.id if self.user else 'N/A'})"
+        )
+        logger.info(f"Connected to {len(self.guilds)} guilds with {total_users} users")
+        logger.info(f"Loaded {len(self.all_slash_commands)} slash commands")
+
+    async def on_slash_command_error(
+        self,
+        interaction: disnake.ApplicationCommandInteraction[SummarizerBot],
+        exception: commands.CommandError,
+    ) -> None:
+        """Handle slash command errors with admin notification."""
+        from src.errors import handle_command_error
+
+        await handle_command_error(self, interaction, exception)
+
+    def setup_extensions(self) -> None:
+        """Load all extensions using pkgutil."""
+        from src import extensions
+
+        for module_info in pkgutil.iter_modules(
+            extensions.__path__, prefix="src.extensions."
+        ):
+            if module_info.name.split(".")[-1].startswith("_"):
+                continue
+            try:
+                self.load_extension(module_info.name)
+                logger.info(f"Loaded extension: {module_info.name}")
+            except Exception as e:
+                logger.error(f"Failed to load extension {module_info.name}: {e}")
+
+
+async def check_api_health(api_url: str) -> bool:
+    """Check if the backend API is available.
+
+    Args:
+        api_url: The API base URL to check
+
+    Returns
+    -------
+        True if API is healthy, False otherwise
+    """
+    try:
+        async with SummarizerClient(base_url=api_url, timeout=10.0) as client:
+            await client.health_check()
+            return True
+    except SummarizerConnectionError:
+        logger.error(f"Cannot connect to API at {api_url}")
+        return False
+    except SummarizerAPIError as e:
+        logger.error(f"API health check failed: {e}")
+        return False
+    except Exception as e:
+        logger.error(f"Unexpected error during API health check: {e}")
+        return False
+
+
+def setup_early_logging() -> None:
+    """Setup minimal logging before config is loaded."""
+    logger.remove()
+    logger.add(
+        sys.stderr,
+        format="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <level>{message}</level>",
+        level="INFO",
+        colorize=True,
+    )
+
+
+async def main() -> None:
+    """Main entry point."""
+    setup_early_logging()
+
+    # Load configuration
+    try:
+        config = load_config()
+    except FileNotFoundError as e:
+        logger.error(f"Configuration error: {e}")
+        logger.info(
+            "Copy config/config.toml.example to config/config.toml and fill in your settings."
+        )
+        sys.exit(1)
+
+    # Check API availability before starting
+    logger.info(f"Checking API availability at {config.bot.api_url}...")
+    if not await check_api_health(config.bot.api_url):
+        logger.critical(
+            "Backend API is not available. Bot cannot start without the API."
+        )
+        logger.info("Please ensure the Summarizer API is running and accessible.")
+        logger.info(f"Expected API URL: {config.bot.api_url}")
+        sys.exit(1)
+
+    logger.success("API health check passed!")
+
+    # Initialize and start bot
+    bot = SummarizerBot(config)
+    bot.setup_extensions()
+
+    logger.info("Starting Discord bot...")
+    await bot.start(config.bot.token)
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

discord_bot/src/config.py

@@ -0,0 +1,70 @@
+"""Configuration management for the Discord bot."""
+
+from __future__ import annotations
+
+import tomllib
+from pathlib import Path
+from typing import Annotated
+
+from pydantic import BaseModel, Field
+
+
+class BotConfig(BaseModel):
+    """Bot configuration loaded from TOML."""
+
+    token: Annotated[str, Field(description="Discord bot token")]
+    application_id: Annotated[int | str, Field(description="Discord application ID")]
+    owner_ids: Annotated[
+        list[int | str], Field(default_factory=list, description="Bot owner user IDs")
+    ]
+    log_level: Annotated[str, Field(default="INFO", description="Logging level")]
+    log_format: Annotated[
+        str,
+        Field(
+            default="<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan> - <level>{message}</level>",
+            description="Loguru format string",
+        ),
+    ]
+    http_timeout: Annotated[
+        float, Field(default=30.0, description="HTTP request timeout")
+    ]
+    max_retries: Annotated[int, Field(default=3, description="Max HTTP retries")]
+    command_prefix: Annotated[
+        list[str],
+        Field(default_factory=lambda: ["s!"], description="Text command prefixes"),
+    ]
+    debug: Annotated[bool, Field(default=False, description="Debug mode")]
+    api_url: Annotated[
+        str, Field(default="http://127.0.0.1:3001/api", description="Backend API URL")
+    ]
+
+
+class Config(BaseModel):
+    """Root configuration model."""
+
+    bot: Annotated[BotConfig, Field(alias="Bot")]
+
+
+def load_config(path: Path | str | None = None) -> Config:
+    """Load configuration from TOML file.
+
+    Args:
+        path: Path to config file. Defaults to config/config.toml
+
+    Returns
+    -------
+        Parsed Config object
+    """
+    if path is None:
+        path = Path(__file__).parent.parent / "config" / "config.toml"
+    elif isinstance(path, str):
+        path = Path(path)
+
+    if not path.exists():
+        msg = f"Config file not found: {path}"
+        raise FileNotFoundError(msg)
+
+    with path.open("rb") as f:
+        data = tomllib.load(f)
+
+    return Config.model_validate(data)

discord_bot/src/embeds.py

@@ -0,0 +1,234 @@
+"""Pastel-themed embed builders for the Summarizer bot."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
+
+import disnake
+
+if TYPE_CHECKING:
+    from sdk import (
+        CacheEntry,
+        CacheStats,
+        LlmInfo,
+        OcrSummarizeResponse,
+        SummarizeResponse,
+    )
+
+
+class Pastel:
+    """Pastel color palette."""
+
+    LAVENDER = 0xE6E6FA
+    MINT = 0x98FF98
+    PEACH = 0xFFDAB9
+    SKY = 0x87CEEB
+    ROSE = 0xFFB6C1
+    LEMON = 0xFFFACD
+    CORAL = 0xF08080
+    LILAC = 0xDDA0DD
+    SAGE = 0xBCB88A
+    BLUSH = 0xDE5D83
+
+
+def summary_embed(response: SummarizeResponse, original_text: str) -> disnake.Embed:
+    """Create embed for summarization result."""
+    embed = disnake.Embed(
+        title="Summary",
+        description=response.summary,
+        color=Pastel.LAVENDER,
+        timestamp=datetime.now(UTC),
+    )
+
+    # Truncate original text preview
+    preview = original_text[:200] + "..." if len(original_text) > 200 else original_text
+    embed.add_field(name="Original", value=f"```{preview}```", inline=False)
+
+    # Metadata in a clean format
+    meta_parts = [f"**Model** {response.model}", f"**Provider** {response.provider}"]
+    if response.style_used:
+        meta_parts.append(f"**Style** {response.style_used}")
+    if response.from_cache:
+        meta_parts.append("**Cached**")
+
+    embed.add_field(name="Details", value=" · ".join(meta_parts), inline=False)
+
+    # Token usage if available
+    if response.token_usage:
+        usage = response.token_usage
+        tokens_text = f"In: {usage.input_tokens} · Out: {usage.output_tokens} · Total: {usage.total_tokens}"
+        if usage.estimated_cost_usd:
+            tokens_text += f" · ${usage.estimated_cost_usd:.4f}"
+        embed.set_footer(text=tokens_text)
+    elif response.processing_time_ms:
+        embed.set_footer(text=f"Processed in {response.processing_time_ms}ms")
+
+    return embed
+
+
+def ocr_summary_embed(response: OcrSummarizeResponse) -> disnake.Embed:
+    """Create embed for OCR summarization result."""
+    embed = disnake.Embed(
+        title="Image Summary",
+        description=response.summary,
+        color=Pastel.MINT,
+        timestamp=datetime.now(UTC),
+    )
+
+    # Extracted text preview
+    extracted = response.extracted_text
+    preview = extracted[:300] + "..." if len(extracted) > 300 else extracted
+    if preview.strip():
+        embed.add_field(name="Extracted Text", value=f"```{preview}```", inline=False)
+
+    # Image info
+    img = response.image_info
+    img_text = f"{img.width}x{img.height} {img.format} · {img.size_bytes / 1024:.1f} KB"
+    embed.add_field(name="Image", value=img_text, inline=True)
+
+    # Timing
+    timing = f"OCR: {response.ocr_time_ms}ms · Total: {response.total_time_ms}ms"
+    embed.add_field(name="Processing", value=timing, inline=True)
+
+    if response.from_cache:
+        embed.set_footer(text="Served from cache")
+
+    return embed
+
+
+def error_embed(title: str, message: str) -> disnake.Embed:
+    """Create embed for error messages."""
+    return disnake.Embed(
+        title=title,
+        description=message,
+        color=Pastel.CORAL,
+        timestamp=datetime.now(UTC),
+    )
+
+
+def success_embed(title: str, message: str) -> disnake.Embed:
+    """Create embed for success messages."""
+    return disnake.Embed(
+        title=title,
+        description=message,
+        color=Pastel.MINT,
+        timestamp=datetime.now(UTC),
+    )
+
+
+def info_embed(title: str, message: str) -> disnake.Embed:
+    """Create embed for informational messages."""
+    return disnake.Embed(
+        title=title,
+        description=message,
+        color=Pastel.SKY,
+        timestamp=datetime.now(UTC),
+    )
+
+
+def loading_embed(message: str = "Processing your request...") -> disnake.Embed:
+    """Create embed for loading/processing state."""
+    return disnake.Embed(
+        title="Working on it",
+        description=message,
+        color=Pastel.LEMON,
+        timestamp=datetime.now(UTC),
+    )
+
+
+def cache_stats_embed(stats: CacheStats) -> disnake.Embed:
+    """Create embed for cache statistics."""
+    embed = disnake.Embed(
+        title="Cache Statistics",
+        color=Pastel.LILAC,
+        timestamp=datetime.now(UTC),
+    )
+
+    embed.add_field(name="Entries", value=f"{stats.total_entries:,}", inline=True)
+    embed.add_field(name="Hit Rate", value=f"{stats.hit_rate:.1f}%", inline=True)
+    embed.add_field(
+        name="Size", value=f"{stats.total_size_bytes / 1024:.1f} KB", inline=True
+    )
+    embed.add_field(name="Hits", value=f"{stats.total_hits:,}", inline=True)
+    embed.add_field(name="Misses", value=f"{stats.total_misses:,}", inline=True)
+
+    return embed
+
+
+def cache_entry_embed(entry: CacheEntry) -> disnake.Embed:
+    """Create embed for a single cache entry."""
+    embed = disnake.Embed(
+        title=f"Cache Entry #{entry.id}",
+        color=Pastel.PEACH,
+        timestamp=datetime.now(UTC),
+    )
+
+    # Summary preview
+    summary_preview = (
+        entry.summary[:500] + "..." if len(entry.summary) > 500 else entry.summary
+    )
+    embed.description = summary_preview
+
+    embed.add_field(name="Model", value=entry.model, inline=True)
+    embed.add_field(name="Provider", value=entry.provider, inline=True)
+    embed.add_field(name="Accesses", value=str(entry.access_count), inline=True)
+    embed.add_field(name="Created", value=entry.created_at, inline=True)
+    embed.add_field(name="Last Used", value=entry.last_accessed, inline=True)
+
+    embed.set_footer(text=f"Checksum: {entry.checksum[:16]}...")
+
+    return embed
+
+
+def models_embed(models: list[LlmInfo]) -> disnake.Embed:
+    """Create embed for available models list."""
+    embed = disnake.Embed(
+        title="Available Models",
+        color=Pastel.SAGE,
+        timestamp=datetime.now(UTC),
+    )
+
+    # Group by provider
+    by_provider: dict[str, list[LlmInfo]] = {}
+    for model in models:
+        if model.provider not in by_provider:
+            by_provider[model.provider] = []
+        by_provider[model.provider].append(model)
+
+    for provider, provider_models in by_provider.items():
+        model_lines: list[str] = []
+        for m in provider_models:
+            status = "available" if m.available else "unavailable"
+            version = f" ({m.version})" if m.version else ""
+            model_lines.append(f"`{m.model}`{version} - {status}")
+        embed.add_field(
+            name=provider.title(), value="\n".join(model_lines), inline=False
+        )
+
+    return embed
+
+
+def help_embed() -> disnake.Embed:
+    """Create help embed with command overview."""
+    embed = disnake.Embed(
+        title="Summarizer Bot",
+        description="Transform long text into concise summaries using AI.",
+        color=Pastel.LAVENDER,
+        timestamp=datetime.now(UTC),
+    )
+
+    commands = [
+        ("`/summarize`", "Summarize text with customizable style and model"),
+        ("`/ocr`", "Extract and summarize text from images"),
+        ("`/models`", "View available AI models"),
+        ("`/cache stats`", "View cache statistics"),
+        ("`/cache clear`", "Clear your cached summaries"),
+    ]
+
+    for name, desc in commands:
+        embed.add_field(name=name, value=desc, inline=False)
+
+    embed.set_footer(text="Use /help <command> for detailed usage")
+
+    return embed

discord_bot/src/errors.py

@@ -0,0 +1,212 @@
+"""Error handling utilities for the bot."""
+
+from __future__ import annotations
+
+import contextlib
+import traceback
+from datetime import UTC, datetime
+
+import disnake
+from disnake.ext import commands
+from loguru import logger
+
+from src.bot import SummarizerBot
+from src.embeds import Pastel, error_embed
+from src.pagination import Paginator, paginate_text
+
+
+def create_error_report_embeds(
+    interaction: disnake.ApplicationCommandInteraction[SummarizerBot],
+    exception: BaseException,
+) -> list[disnake.Embed]:
+    """Create detailed error report embeds for admins/owners."""
+    error_id = f"{interaction.id}"
+    timestamp = datetime.now(UTC)
+
+    # Format the traceback
+    tb_lines = traceback.format_exception(
+        type(exception), exception, exception.__traceback__
+    )
+    tb_text = "".join(tb_lines)
+
+    # Build context info
+    guild_info = (
+        f"{interaction.guild.name} ({interaction.guild_id})"
+        if interaction.guild
+        else "DM"
+    )
+    channel_info = f"#{interaction.channel}" if interaction.channel else "Unknown"
+
+    context = (
+        f"**Error ID:** `{error_id}`\n"
+        f"**Command:** `/{interaction.application_command.name}`\n"
+        f"**User:** {interaction.author} (`{interaction.author.id}`)\n"
+        f"**Guild:** {guild_info}\n"
+        f"**Channel:** {channel_info}\n"
+        f"**Time:** <t:{int(timestamp.timestamp())}:F>"
+    )
+
+    # First embed with context
+    embeds: list[disnake.Embed] = []
+
+    header_embed = disnake.Embed(
+        title="Error Report",
+        description=context,
+        color=Pastel.CORAL,
+        timestamp=timestamp,
+    )
+    header_embed.add_field(
+        name="Exception Type",
+        value=f"`{type(exception).__name__}`",
+        inline=True,
+    )
+    header_embed.add_field(
+        name="Message",
+        value=str(exception)[:1024] or "No message",
+        inline=False,
+    )
+    embeds.append(header_embed)
+
+    # Paginate traceback if needed
+    if len(tb_text) > 4000:
+        chunks = paginate_text(tb_text, max_length=4000)
+        for i, chunk in enumerate(chunks, 1):
+            tb_embed = disnake.Embed(
+                title=f"Traceback ({i}/{len(chunks)})",
+                description=f"```python\n{chunk}\n```",
+                color=Pastel.CORAL,
+            )
+            embeds.append(tb_embed)
+    else:
+        tb_embed = disnake.Embed(
+            title="Traceback",
+            description=f"```python\n{tb_text}\n```",
+            color=Pastel.CORAL,
+        )
+        embeds.append(tb_embed)
+
+    # Add footer to last embed
+    embeds[-1].set_footer(text=f"Error ID: {error_id}")
+
+    return embeds
+
+
+async def notify_owners(
+    bot: SummarizerBot,
+    embeds: list[disnake.Embed],
+) -> None:
+    """Send error report to all bot owners via DM."""
+    for owner_id in bot.config.bot.owner_ids:
+        try:
+            user = await bot.fetch_user(int(owner_id))
+            if len(embeds) == 1:
+                await user.send(embed=embeds[0])
+            else:
+                # Use paginator for multiple embeds
+                view = Paginator(embeds, author_id=user.id)
+                view.update_page_indicator()
+                await user.send(embed=embeds[0], view=view)
+        except disnake.Forbidden:
+            logger.warning(f"Cannot DM owner {owner_id} - DMs disabled")
+        except disnake.NotFound:
+            logger.warning(f"Owner {owner_id} not found")
+        except Exception as e:  # noqa: BLE001
+            logger.error(f"Failed to notify owner {owner_id}: {e}")
+
+
+def is_privileged_user(
+    bot: SummarizerBot,
+    user_id: int,
+) -> bool:
+    """Check if user is an owner or admin."""
+    return str(user_id) in bot.config.bot.owner_ids
+
+
+async def handle_command_error(
+    bot: SummarizerBot,
+    interaction: disnake.ApplicationCommandInteraction[SummarizerBot],
+    exception: commands.CommandError,
+) -> None:
+    """Handle command errors with proper user feedback and admin notification."""
+    # Handle known error types with specific messages
+    if isinstance(exception, commands.CheckFailure):
+        await _send_error_response(
+            interaction,
+            "Permission Denied",
+            "You don't have permission to use this command.",
+        )
+        return
+
+    if isinstance(exception, commands.CommandOnCooldown):
+        await _send_error_response(
+            interaction,
+            "Cooldown",
+            f"Please wait {exception.retry_after:.1f}s before using this command again.",
+        )
+        return
+
+    if isinstance(exception, commands.MissingPermissions):
+        perms = ", ".join(exception.missing_permissions)
+        await _send_error_response(
+            interaction,
+            "Missing Permissions",
+            f"You need the following permissions: {perms}",
+        )
+        return
+
+    if isinstance(exception, commands.BotMissingPermissions):
+        perms = ", ".join(exception.missing_permissions)
+        await _send_error_response(
+            interaction,
+            "Bot Missing Permissions",
+            f"I need the following permissions: {perms}",
+        )
+        return
+
+    # Log the error
+    logger.exception(
+        f"Unhandled error in /{interaction.application_command.name}: {exception}"
+    )
+
+    # For privileged users, show the actual error
+    if is_privileged_user(bot, interaction.author.id):
+        error_msg = f"```\n{type(exception).__name__}: {exception}\n```"
+        if len(error_msg) > 4000:
+            error_msg = error_msg[:3997] + "```"
+        await _send_error_response(
+            interaction,
+            "Error (Admin View)",
+            error_msg,
+        )
+    else:
+        # Generic message for regular users
+        await _send_error_response(
+            interaction,
+            "Something went wrong",
+            "An unexpected error occurred. The bot administrators have been notified.",
+        )
+
+    # Create and send error report to owners
+    try:
+        error_embeds = create_error_report_embeds(interaction, exception)
+        await notify_owners(bot, error_embeds)
+    except Exception as e:  # noqa: BLE001
+        logger.error(f"Failed to create/send error report: {e}")
+
+
+async def _send_error_response(
+    interaction: disnake.ApplicationCommandInteraction[SummarizerBot],
+    title: str,
+    message: str,
+) -> None:
+    """Send an error response to the user."""
+    embed = error_embed(title, message)
+    try:
+        if interaction.response.is_done():
+            await interaction.edit_original_response(embed=embed)
+        else:
+            await interaction.response.send_message(embed=embed, ephemeral=True)
+    except Exception:  # noqa: BLE001
+        # Last resort - try followup
+        with contextlib.suppress(Exception):
+            await interaction.followup.send(embed=embed, ephemeral=True)

discord_bot/src/extensions/__init__.py

@@ -0,0 +1 @@
+"""Bot extensions package."""

discord_bot/src/extensions/admin.py

@@ -0,0 +1,226 @@
+"""Admin commands cog for bot owners."""
+
+from __future__ import annotations
+
+import contextlib
+from typing import Any
+
+import disnake
+from disnake.ext import commands
+from loguru import logger
+
+from sdk import SummarizerAPIError, SummarizerClient, SummarizerRateLimitError
+from src.bot import SummarizerBot
+from src.embeds import error_embed, help_embed, info_embed, success_embed
+from src.errors import create_error_report_embeds, notify_owners
+
+# Rate limit for admin commands: 5 uses per 30 seconds per user
+ADMIN_COOLDOWN = commands.CooldownMapping.from_cooldown(
+    5, 30.0, commands.BucketType.user
+)
+
+
+def check_cooldown(
+    mapping: commands.CooldownMapping,
+    inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+) -> float | None:
+    """Check if user is on cooldown. Returns retry_after if on cooldown."""
+    bucket = mapping.get_bucket(inter)
+    if bucket:
+        return bucket.update_rate_limit()
+    return None
+
+
+def is_owner() -> Any:  # noqa: ANN401
+    """Check if user is a bot owner."""
+
+    async def predicate(
+        inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+    ) -> bool:
+        return str(inter.author.id) in inter.bot.config.bot.owner_ids
+
+    return commands.check(predicate)  # type: ignore[arg-type]
+
+
+class AdminCog(commands.Cog):
+    """Admin-only commands for bot management."""
+
+    def __init__(self, bot: SummarizerBot) -> None:
+        self.bot = bot
+
+    @commands.slash_command(name="help", description="Show bot help and commands")
+    async def help_command(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Display help information."""
+        await inter.response.send_message(embed=help_embed())
+
+    @commands.slash_command(name="ping", description="Check bot latency")
+    async def ping(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Check bot and API latency."""
+        # Check rate limit
+        retry_after = check_cooldown(ADMIN_COOLDOWN, inter)
+        if retry_after:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Cooldown",
+                    f"Please wait {retry_after:.1f}s before using this command again.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        await inter.response.defer()
+
+        bot_latency = round(self.bot.latency * 1000)
+
+        # Check API health
+        api_status = "offline"
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                await client.health_check()
+                api_status = "online"
+        except SummarizerAPIError:
+            api_status = "error"
+        except Exception:  # noqa: BLE001
+            api_status = "unreachable"
+
+        embed = info_embed(
+            "Pong",
+            f"**Bot** {bot_latency}ms\n**API** {api_status}",
+        )
+        await inter.edit_original_response(embed=embed)
+
+    @commands.slash_command(name="admin", description="Admin commands")
+    @is_owner()
+    async def admin(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Parent command for admin operations."""
+
+    @admin.sub_command(
+        name="clear-guild-cache", description="Clear all cache for this server"
+    )
+    async def clear_guild_cache(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Clear all cache entries for the current guild."""
+        if not inter.guild_id:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Server Only", "This command can only be used in a server."
+                ),
+                ephemeral=True,
+            )
+            return
+
+        await inter.response.defer(ephemeral=True)
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                result = await client.delete_cache(guild_id=str(inter.guild_id))
+
+            await inter.edit_original_response(
+                embed=success_embed("Guild Cache Cleared", result.message)
+            )
+
+        except SummarizerRateLimitError as e:
+            logger.warning(f"Rate limit clearing guild cache: {e}")
+            await inter.edit_original_response(
+                embed=error_embed(
+                    "Rate Limited",
+                    "API rate limit exceeded. Please try again later.",
+                )
+            )
+        except SummarizerAPIError as e:
+            logger.warning(f"API error clearing guild cache: {e}")
+            await inter.edit_original_response(embed=error_embed("Failed", str(e)))
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error clearing guild cache")
+            await inter.edit_original_response(
+                embed=error_embed(
+                    "Something went wrong", "An unexpected error occurred."
+                )
+            )
+            # Notify owners
+            with contextlib.suppress(Exception):
+                error_embeds = create_error_report_embeds(inter, e)
+                await notify_owners(self.bot, error_embeds)
+
+    @admin.sub_command(
+        name="clear-all-cache", description="Clear entire cache (dangerous)"
+    )
+    async def clear_all_cache(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Clear all cache entries globally."""
+        await inter.response.defer(ephemeral=True)
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                result = await client.delete_cache(delete_all=True)
+
+            await inter.edit_original_response(
+                embed=success_embed("All Cache Cleared", result.message)
+            )
+
+        except SummarizerRateLimitError as e:
+            logger.warning(f"Rate limit clearing all cache: {e}")
+            await inter.edit_original_response(
+                embed=error_embed(
+                    "Rate Limited",
+                    "API rate limit exceeded. Please try again later.",
+                )
+            )
+        except SummarizerAPIError as e:
+            logger.warning(f"API error clearing all cache: {e}")
+            await inter.edit_original_response(embed=error_embed("Failed", str(e)))
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error clearing all cache")
+            await inter.edit_original_response(
+                embed=error_embed(
+                    "Something went wrong", "An unexpected error occurred."
+                )
+            )
+            # Notify owners
+            with contextlib.suppress(Exception):
+                error_embeds = create_error_report_embeds(inter, e)
+                await notify_owners(self.bot, error_embeds)
+
+    @admin.sub_command(name="status", description="Show bot status")
+    async def status(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Show detailed bot status."""
+        await inter.response.defer(ephemeral=True)
+
+        guilds = len(self.bot.guilds)
+        users = sum(g.member_count or 0 for g in self.bot.guilds)
+
+        # Get cache stats
+        cache_info = "unavailable"
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                stats = await client.get_cache_stats()
+                cache_info = (
+                    f"{stats.total_entries:,} entries · "
+                    f"{stats.hit_rate:.1f}% hit rate"
+                )
+        except Exception:  # noqa: BLE001
+            logger.debug("Failed to get cache stats for status command")
+
+        embed = info_embed(
+            "Bot Status",
+            f"**Servers** {guilds:,}\n"
+            f"**Users** {users:,}\n"
+            f"**Cache** {cache_info}\n"
+            f"**API** {self.bot.config.bot.api_url}",
+        )
+        await inter.edit_original_response(embed=embed)
+
+
+def setup(bot: SummarizerBot) -> None:
+    """Load the cog."""
+    bot.add_cog(AdminCog(bot))

discord_bot/src/extensions/cache.py

@@ -0,0 +1,119 @@
+"""Cache management commands cog."""
+
+from __future__ import annotations
+
+import disnake
+from disnake.ext import commands
+from loguru import logger
+
+from sdk import SummarizerAPIError, SummarizerClient
+from src.bot import SummarizerBot
+from src.embeds import cache_entry_embed, cache_stats_embed, error_embed, success_embed
+
+
+class CacheCog(commands.Cog):
+    """Commands for cache management."""
+
+    def __init__(self, bot: SummarizerBot) -> None:
+        self.bot = bot
+
+    @commands.slash_command(name="cache", description="Cache management commands")
+    async def cache(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Parent command for cache operations."""
+
+    @cache.sub_command(name="stats", description="View cache statistics")
+    async def cache_stats(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Display cache statistics."""
+        await inter.response.defer()
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                stats = await client.get_cache_stats()
+
+            await inter.edit_original_response(embed=cache_stats_embed(stats))
+
+        except SummarizerAPIError as e:
+            logger.warning(f"API error getting cache stats: {e}")
+            await inter.edit_original_response(
+                embed=error_embed("Failed to Get Stats", str(e))
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error getting cache stats")
+            await inter.edit_original_response(
+                embed=error_embed("Something went wrong", str(e))
+            )
+
+    @cache.sub_command(name="list", description="List your cached summaries")
+    async def cache_list(
+        self,
+        inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+        limit: int = commands.Param(
+            description="Number of entries to show", default=5, ge=1, le=25
+        ),
+    ) -> None:
+        """List user's cached summaries."""
+        await inter.response.defer(ephemeral=True)
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                entries = await client.get_user_cache(str(inter.author.id))
+
+            if not entries:
+                await inter.edit_original_response(
+                    embed=success_embed(
+                        "No Cache Entries", "You don't have any cached summaries yet."
+                    )
+                )
+                return
+
+            # Show limited entries
+            entries = entries[:limit]
+            embeds = [cache_entry_embed(entry) for entry in entries]
+
+            await inter.edit_original_response(embeds=embeds[:10])  # Discord limit
+
+        except SummarizerAPIError as e:
+            logger.warning(f"API error listing cache: {e}")
+            await inter.edit_original_response(
+                embed=error_embed("Failed to List Cache", str(e))
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error listing cache")
+            await inter.edit_original_response(
+                embed=error_embed("Something went wrong", str(e))
+            )
+
+    @cache.sub_command(name="clear", description="Clear your cached summaries")
+    async def cache_clear(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """Clear user's cached summaries."""
+        await inter.response.defer(ephemeral=True)
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                result = await client.delete_cache(user_id=str(inter.author.id))
+
+            await inter.edit_original_response(
+                embed=success_embed("Cache Cleared", result.message)
+            )
+
+        except SummarizerAPIError as e:
+            logger.warning(f"API error clearing cache: {e}")
+            await inter.edit_original_response(
+                embed=error_embed("Failed to Clear Cache", str(e))
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error clearing cache")
+            await inter.edit_original_response(
+                embed=error_embed("Something went wrong", str(e))
+            )
+
+
+def setup(bot: SummarizerBot) -> None:
+    """Load the cog."""
+    bot.add_cog(CacheCog(bot))

discord_bot/src/extensions/summarize.py

@@ -0,0 +1,608 @@
+"""Summarization commands cog."""
+
+from __future__ import annotations
+
+import contextlib
+from datetime import UTC, datetime
+
+import disnake
+from disnake.ext import commands
+from loguru import logger
+
+from sdk import (
+    LlmProvider,
+    SummarizationStyle,
+    SummarizerAPIError,
+    SummarizerClient,
+    SummarizerRateLimitError,
+)
+from src.bot import SummarizerBot
+from src.embeds import error_embed, models_embed, ocr_summary_embed, summary_embed
+from src.errors import create_error_report_embeds, notify_owners
+from src.views import QuickSummarizeView
+
+# Rate limit: 5 uses per 60 seconds per user
+SUMMARIZE_COOLDOWN = commands.CooldownMapping.from_cooldown(
+    5, 60.0, commands.BucketType.user
+)
+
+# Rate limit for bulk: 3 uses per 120 seconds per user
+BULK_COOLDOWN = commands.CooldownMapping.from_cooldown(
+    3, 120.0, commands.BucketType.user
+)
+
+# Rate limit for OCR: 3 uses per 60 seconds per user
+OCR_COOLDOWN = commands.CooldownMapping.from_cooldown(3, 60.0, commands.BucketType.user)
+
+
+def check_cooldown(
+    mapping: commands.CooldownMapping,
+    inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+) -> float | None:
+    """Check if user is on cooldown. Returns retry_after if on cooldown."""
+    bucket = mapping.get_bucket(inter)
+    if bucket:
+        return bucket.update_rate_limit()
+    return None
+
+
+class SummarizeCog(commands.Cog):
+    """Commands for text and image summarization."""
+
+    def __init__(self, bot: SummarizerBot) -> None:
+        self.bot = bot
+
+    @commands.slash_command(
+        name="summarize", description="Summarize a message by ID or reply."
+    )
+    async def summarize(
+        self,
+        inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+        message_id: str = commands.Param(
+            description="Message ID to summarize (or reply to a message)",
+            default=None,
+        ),
+        style: str = commands.Param(
+            description="Summary style",
+            default=None,
+            choices=[
+                "brief",
+                "detailed",
+                "funny",
+                "professional",
+                "technical",
+                "eli5",
+                "bullets",
+                "academic",
+                "roast",
+            ],
+        ),
+    ) -> None:
+        """Summarize a message. Provide message_id or reply to a message."""
+        # Check rate limit
+        retry_after = check_cooldown(SUMMARIZE_COOLDOWN, inter)
+        if retry_after:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Cooldown",
+                    f"Please wait {retry_after:.1f}s before using this command again.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        # Determine which message to summarize first (before deferring)
+        target_message: disnake.Message | None = None
+
+        # Check if this is a reply to a message
+        if hasattr(inter, "message") and inter.message and inter.message.reference:
+            ref = inter.message.reference
+            if ref.message_id:
+                with contextlib.suppress(disnake.NotFound):
+                    target_message = await inter.channel.fetch_message(ref.message_id)
+
+        # If no reply, try message_id parameter
+        if target_message is None and message_id:
+            try:
+                msg_id = int(message_id)
+                target_message = await inter.channel.fetch_message(msg_id)
+            except ValueError:
+                await inter.response.send_message(
+                    embed=error_embed(
+                        "Invalid Message ID",
+                        "Please provide a valid message ID (numbers only).\n\n"
+                        "**Tip:** Enable Developer Mode in Discord settings "
+                        "to copy message IDs, or reply to the message.",
+                    ),
+                    ephemeral=True,
+                )
+                return
+            except disnake.NotFound:
+                await inter.response.send_message(
+                    embed=error_embed(
+                        "Message Not Found",
+                        "Could not find a message with that ID in this channel.\n\n"
+                        "Make sure the message exists and is in this channel.",
+                    ),
+                    ephemeral=True,
+                )
+                return
+            except disnake.Forbidden:
+                await inter.response.send_message(
+                    embed=error_embed(
+                        "Access Denied",
+                        "I don't have permission to read that message.",
+                    ),
+                    ephemeral=True,
+                )
+                return
+
+        # No message found
+        if target_message is None:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "No Message Specified",
+                    "Please provide a message ID or reply to a message.\n\n"
+                    "**Usage:**\n"
+                    "• `/summarize message_id:123456789` - Summarize by ID\n"
+                    "• Reply to a message and use `/summarize`\n\n"
+                    "**Tip:** Right-click → Copy Message ID (Developer Mode)",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        # Check if message has content
+        text = target_message.content
+        if not text or not text.strip():
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Empty Message",
+                    "That message has no text content to summarize.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        llm_style = SummarizationStyle(style) if style else None
+
+        # Create callback for summarization
+        async def do_summarize(provider: str, model: str | None) -> None:
+            try:
+                llm_provider = LlmProvider(provider)
+                async with SummarizerClient(
+                    base_url=self.bot.config.bot.api_url
+                ) as client:
+                    response = await client.summarize(
+                        text=text,
+                        provider=llm_provider,
+                        guild_id=str(inter.guild_id or 0),
+                        user_id=str(inter.author.id),
+                        channel_id=str(inter.channel_id) if inter.channel_id else None,
+                        style=llm_style,
+                        model=model,
+                    )
+                embed = summary_embed(response, text)
+                await inter.edit_original_response(embed=embed, view=None)
+            except SummarizerRateLimitError as e:
+                logger.warning(f"Rate limit from API in summarize: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Rate Limited",
+                        "The API rate limit has been exceeded. Please try again later.",
+                    ),
+                    view=None,
+                )
+            except SummarizerAPIError as e:
+                logger.warning(f"API error in summarize: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed("Summarization Failed", str(e)), view=None
+                )
+            except Exception as e:  # noqa: BLE001
+                logger.exception("Unexpected error in summarize")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Something went wrong", "An unexpected error occurred."
+                    ),
+                    view=None,
+                )
+                with contextlib.suppress(Exception):
+                    error_embeds = create_error_report_embeds(inter, e)
+                    await notify_owners(self.bot, error_embeds)
+
+        # Show provider/model selection view
+        view = QuickSummarizeView(self.bot, do_summarize, author_id=inter.author.id)
+        preview = text[:200] + ("..." if len(text) > 200 else "")
+        embed = disnake.Embed(
+            title="📝 Summarize Message",
+            description=(
+                f"Ready to summarize message from "
+                f"**{target_message.author.display_name}**\n\n"
+                f"**Preview:** {preview}\n\n"
+                f"**Style:** {style or 'Default'}"
+            ),
+            color=disnake.Color.blurple(),
+        )
+        await inter.response.send_message(embed=embed, view=view)
+
+    @commands.slash_command(
+        name="bulk-summarize",
+        description="Summarize multiple messages from the channel.",
+    )
+    async def bulk_summarize(
+        self,
+        inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+        messages: int = commands.Param(
+            description="Number of messages to summarize (max 100)",
+            ge=1,
+            le=100,
+        ),
+        style: str = commands.Param(
+            description="Summary style",
+            default=None,
+            choices=[
+                "brief",
+                "detailed",
+                "funny",
+                "professional",
+                "technical",
+                "eli5",
+                "bullets",
+                "academic",
+                "roast",
+            ],
+        ),
+        user: disnake.User | None = None,
+        after: str = commands.Param(
+            description="Only messages after date/time (YYYY-MM-DD HH:MM)",
+            default=None,
+        ),
+        before: str = commands.Param(
+            description="Only messages before date/time (YYYY-MM-DD HH:MM)",
+            default=None,
+        ),
+        include_bots: bool = False,  # noqa: FBT001, FBT002
+    ) -> None:
+        """Summarize multiple messages with filtering options."""
+        # Check rate limit
+        retry_after = check_cooldown(BULK_COOLDOWN, inter)
+        if retry_after:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Cooldown",
+                    f"Please wait {retry_after:.1f}s before using this command again.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        # Parse date filters first (before any response)
+        after_dt: datetime | None = None
+        before_dt: datetime | None = None
+
+        if after:
+            after_dt = self._parse_datetime(after)
+            if after_dt is None:
+                await inter.response.send_message(
+                    embed=error_embed(
+                        "Invalid Date Format",
+                        f"Could not parse 'after' date: `{after}`\n\n"
+                        "Use format: `YYYY-MM-DD` or `YYYY-MM-DD HH:MM`",
+                    ),
+                    ephemeral=True,
+                )
+                return
+
+        if before:
+            before_dt = self._parse_datetime(before)
+            if before_dt is None:
+                await inter.response.send_message(
+                    embed=error_embed(
+                        "Invalid Date Format",
+                        f"Could not parse 'before' date: `{before}`\n\n"
+                        "Use format: `YYYY-MM-DD` or `YYYY-MM-DD HH:MM`",
+                    ),
+                    ephemeral=True,
+                )
+                return
+
+        # Fetch messages with filters
+        collected_messages: list[disnake.Message] = []
+        fetch_limit = messages * 3  # Fetch more to account for filtering
+
+        async for msg in inter.channel.history(
+            limit=fetch_limit,
+            after=after_dt,
+            before=before_dt,
+        ):
+            # Skip bots if not included
+            if not include_bots and msg.author.bot:
+                continue
+
+            # Filter by user if specified
+            if user and msg.author.id != user.id:
+                continue
+
+            # Skip empty messages
+            if not msg.content or not msg.content.strip():
+                continue
+
+            collected_messages.append(msg)
+
+            if len(collected_messages) >= messages:
+                break
+
+        if not collected_messages:
+            filter_info: list[str] = []
+            if user:
+                filter_info.append(f"from {user.mention}")
+            if after_dt:
+                filter_info.append(f"after {after}")
+            if before_dt:
+                filter_info.append(f"before {before}")
+            if not include_bots:
+                filter_info.append("excluding bots")
+
+            filter_str = (
+                ", ".join(filter_info) if filter_info else "with current filters"
+            )
+
+            await inter.response.send_message(
+                embed=error_embed(
+                    "No Messages Found",
+                    f"No messages found {filter_str}.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        # Build text from messages (oldest first)
+        collected_messages.reverse()
+        text_parts: list[str] = []
+        for msg in collected_messages:
+            timestamp = msg.created_at.strftime("%Y-%m-%d %H:%M")
+            text_parts.append(f"[{timestamp}] {msg.author.display_name}: {msg.content}")
+
+        text = "\n".join(text_parts)
+        llm_style = SummarizationStyle(style) if style else None
+        msg_count = len(collected_messages)
+
+        # Create callback for summarization
+        async def do_bulk_summarize(provider: str, model: str | None) -> None:
+            try:
+                llm_provider = LlmProvider(provider)
+                async with SummarizerClient(
+                    base_url=self.bot.config.bot.api_url
+                ) as client:
+                    response = await client.summarize(
+                        text=text,
+                        provider=llm_provider,
+                        guild_id=str(inter.guild_id or 0),
+                        user_id=str(inter.author.id),
+                        channel_id=str(inter.channel_id) if inter.channel_id else None,
+                        style=llm_style,
+                        model=model,
+                    )
+                embed = summary_embed(response, text)
+                embed.set_footer(text=f"Summarized {msg_count} messages")
+                await inter.edit_original_response(embed=embed, view=None)
+            except SummarizerRateLimitError as e:
+                logger.warning(f"Rate limit from API in bulk_summarize: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Rate Limited",
+                        "The API rate limit has been exceeded. Please try again later.",
+                    ),
+                    view=None,
+                )
+            except SummarizerAPIError as e:
+                logger.warning(f"API error in bulk_summarize: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed("Summarization Failed", str(e)), view=None
+                )
+            except Exception as e:  # noqa: BLE001
+                logger.exception("Unexpected error in bulk_summarize")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Something went wrong", "An unexpected error occurred."
+                    ),
+                    view=None,
+                )
+                with contextlib.suppress(Exception):
+                    error_embeds = create_error_report_embeds(inter, e)
+                    await notify_owners(self.bot, error_embeds)
+
+        # Show provider/model selection view
+        view = QuickSummarizeView(
+            self.bot, do_bulk_summarize, author_id=inter.author.id
+        )
+
+        # Build filter description
+        filter_parts: list[str] = []
+        if user:
+            filter_parts.append(f"From: {user.mention}")
+        if after:
+            filter_parts.append(f"After: {after}")
+        if before:
+            filter_parts.append(f"Before: {before}")
+        if include_bots:
+            filter_parts.append("Including bots")
+        filter_desc = "\n".join(filter_parts) if filter_parts else "No filters"
+
+        embed = disnake.Embed(
+            title="📚 Bulk Summarize",
+            description=(
+                f"Ready to summarize **{msg_count}** messages\n\n"
+                f"**Filters:**\n{filter_desc}\n\n"
+                f"**Style:** {style or 'Default'}"
+            ),
+            color=disnake.Color.blurple(),
+        )
+        await inter.response.send_message(embed=embed, view=view)
+
+    def _parse_datetime(self, date_str: str) -> datetime | None:
+        """Parse a date/datetime string into a datetime object."""
+        formats = [
+            "%Y-%m-%d %H:%M",
+            "%Y-%m-%d %H:%M:%S",
+            "%Y-%m-%d",
+            "%d/%m/%Y %H:%M",
+            "%d/%m/%Y",
+        ]
+        for fmt in formats:
+            try:
+                dt = datetime.strptime(date_str.strip(), fmt)  # noqa: DTZ007
+                return dt.replace(tzinfo=UTC)
+            except ValueError:
+                continue
+        return None
+
+    @commands.slash_command(
+        name="ocr", description="Extract and summarize text from an image"
+    )
+    async def ocr_summarize(
+        self,
+        inter: disnake.ApplicationCommandInteraction[SummarizerBot],
+        image: disnake.Attachment = commands.Param(  # noqa: B008
+            description="Image to process"
+        ),
+        style: str = commands.Param(
+            description="Summary style",
+            default=None,
+            choices=[
+                "brief",
+                "detailed",
+                "funny",
+                "professional",
+                "technical",
+                "eli5",
+                "bullets",
+                "academic",
+                "roast",
+            ],
+        ),
+    ) -> None:
+        """OCR and summarize an image."""
+        # Check rate limit
+        retry_after = check_cooldown(OCR_COOLDOWN, inter)
+        if retry_after:
+            await inter.response.send_message(
+                embed=error_embed(
+                    "Cooldown",
+                    f"Please wait {retry_after:.1f}s before using this command again.",
+                ),
+                ephemeral=True,
+            )
+            return
+
+        # Validate image
+        if not image.content_type or not image.content_type.startswith("image/"):
+            await inter.response.send_message(
+                embed=error_embed("Invalid File", "Please upload an image file."),
+                ephemeral=True,
+            )
+            return
+
+        # Read image data before showing the view
+        image_data = await image.read()
+        llm_style = SummarizationStyle(style) if style else None
+
+        # Create callback for OCR summarization
+        async def do_ocr_summarize(provider: str, model: str | None) -> None:
+            try:
+                llm_provider = LlmProvider(provider)
+                async with SummarizerClient(
+                    base_url=self.bot.config.bot.api_url
+                ) as client:
+                    response = await client.ocr_summarize(
+                        image_data=image_data,
+                        provider=llm_provider,
+                        guild_id=str(inter.guild_id or 0),
+                        user_id=str(inter.author.id),
+                        channel_id=str(inter.channel_id) if inter.channel_id else None,
+                        style=llm_style,
+                        model=model,
+                    )
+                embed = ocr_summary_embed(response)
+                await inter.edit_original_response(embed=embed, view=None)
+            except SummarizerRateLimitError as e:
+                logger.warning(f"Rate limit from API in ocr: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Rate Limited",
+                        "The API rate limit has been exceeded. Please try again later.",
+                    ),
+                    view=None,
+                )
+            except SummarizerAPIError as e:
+                logger.warning(f"API error in ocr: {e}")
+                await inter.edit_original_response(
+                    embed=error_embed("OCR Failed", str(e)), view=None
+                )
+            except Exception as e:  # noqa: BLE001
+                logger.exception("Unexpected error in ocr")
+                await inter.edit_original_response(
+                    embed=error_embed(
+                        "Something went wrong", "An unexpected error occurred."
+                    ),
+                    view=None,
+                )
+                with contextlib.suppress(Exception):
+                    error_embeds = create_error_report_embeds(inter, e)
+                    await notify_owners(self.bot, error_embeds)
+
+        # Show provider/model selection view
+        view = QuickSummarizeView(self.bot, do_ocr_summarize, author_id=inter.author.id)
+
+        # Format file size
+        size_kb = image.size / 1024 if image.size else 0
+        size_str = f"{size_kb:.1f} KB" if size_kb < 1024 else f"{size_kb/1024:.1f} MB"
+
+        embed = disnake.Embed(
+            title="🖼️ OCR & Summarize",
+            description=(
+                f"Ready to extract and summarize text from image\n\n"
+                f"**File:** {image.filename}\n"
+                f"**Size:** {size_str}\n"
+                f"**Style:** {style or 'Default'}"
+            ),
+            color=disnake.Color.blurple(),
+        )
+        if image.url:
+            embed.set_thumbnail(url=image.url)
+        await inter.response.send_message(embed=embed, view=view)
+
+    @commands.slash_command(name="models", description="List available AI models")
+    async def list_models(
+        self, inter: disnake.ApplicationCommandInteraction[SummarizerBot]
+    ) -> None:
+        """List available LLM models."""
+        await inter.response.defer()
+
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                models_list = await client.list_models()
+
+            await inter.edit_original_response(embed=models_embed(models_list))
+
+        except SummarizerAPIError as e:
+            logger.warning(f"API error listing models: {e}")
+            await inter.edit_original_response(
+                embed=error_embed("Failed to List Models", str(e))
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Unexpected error listing models")
+            await inter.edit_original_response(
+                embed=error_embed(
+                    "Something went wrong", "An unexpected error occurred."
+                )
+            )
+            # Notify owners
+            with contextlib.suppress(Exception):
+                error_embeds = create_error_report_embeds(inter, e)
+                await notify_owners(self.bot, error_embeds)
+
+
+def setup(bot: SummarizerBot) -> None:
+    """Load the cog."""
+    bot.add_cog(SummarizeCog(bot))

discord_bot/src/pagination.py

@@ -0,0 +1,225 @@
+"""Pagination utilities for long content."""
+
+from __future__ import annotations
+
+import disnake
+
+
+class Paginator(disnake.ui.View):
+    """Interactive paginator for long content."""
+
+    def __init__(
+        self,
+        embeds: list[disnake.Embed],
+        *,
+        author_id: int | None = None,
+        timeout: float = 180.0,
+    ) -> None:
+        super().__init__(timeout=timeout)
+        self.embeds = embeds
+        self.author_id = author_id
+        self.current_page = 0
+        self.total_pages = len(embeds)
+
+        self._update_buttons()
+
+    def _update_buttons(self) -> None:
+        """Update button states based on current page."""
+        self.first_button.disabled = self.current_page == 0
+        self.prev_button.disabled = self.current_page == 0
+        self.next_button.disabled = self.current_page >= self.total_pages - 1
+        self.last_button.disabled = self.current_page >= self.total_pages - 1
+
+    async def interaction_check(self, interaction: disnake.MessageInteraction) -> bool:
+        """Check if the user can interact with the paginator."""
+        if self.author_id and interaction.author.id != self.author_id:
+            await interaction.response.send_message(
+                "This paginator isn't for you.", ephemeral=True
+            )
+            return False
+        return True
+
+    @disnake.ui.button(label="≪", style=disnake.ButtonStyle.secondary)
+    async def first_button(
+        self,
+        button: disnake.ui.Button[Paginator],
+        interaction: disnake.MessageInteraction,
+    ) -> None:
+        """Go to first page."""
+        self.current_page = 0
+        self._update_buttons()
+        await interaction.response.edit_message(
+            embed=self.embeds[self.current_page], view=self
+        )
+
+    @disnake.ui.button(label="◀", style=disnake.ButtonStyle.primary)
+    async def prev_button(
+        self,
+        button: disnake.ui.Button[Paginator],
+        interaction: disnake.MessageInteraction,
+    ) -> None:
+        """Go to previous page."""
+        self.current_page = max(0, self.current_page - 1)
+        self._update_buttons()
+        await interaction.response.edit_message(
+            embed=self.embeds[self.current_page], view=self
+        )
+
+    @disnake.ui.button(label="•", style=disnake.ButtonStyle.secondary, disabled=True)
+    async def page_indicator(
+        self,
+        button: disnake.ui.Button[Paginator],
+        interaction: disnake.MessageInteraction,
+    ) -> None:
+        """Page indicator (non-interactive)."""
+
+    @disnake.ui.button(label="▶", style=disnake.ButtonStyle.primary)
+    async def next_button(
+        self,
+        button: disnake.ui.Button[Paginator],
+        interaction: disnake.MessageInteraction,
+    ) -> None:
+        """Go to next page."""
+        self.current_page = min(self.total_pages - 1, self.current_page + 1)
+        self._update_buttons()
+        await interaction.response.edit_message(
+            embed=self.embeds[self.current_page], view=self
+        )
+
+    @disnake.ui.button(label="≫", style=disnake.ButtonStyle.secondary)
+    async def last_button(
+        self,
+        button: disnake.ui.Button[Paginator],
+        interaction: disnake.MessageInteraction,
+    ) -> None:
+        """Go to last page."""
+        self.current_page = self.total_pages - 1
+        self._update_buttons()
+        await interaction.response.edit_message(
+            embed=self.embeds[self.current_page], view=self
+        )
+
+    def update_page_indicator(self) -> None:
+        """Update the page indicator label."""
+        self.page_indicator.label = f"{self.current_page + 1}/{self.total_pages}"
+
+    async def on_timeout(self) -> None:
+        """Disable all buttons on timeout."""
+        for item in self.children:
+            if isinstance(item, disnake.ui.Button):
+                item.disabled = True
+
+
+def paginate_text(text: str, max_length: int = 4000) -> list[str]:
+    """Split text into chunks that fit within Discord's limits.
+
+    Tries to split on paragraph boundaries, then sentences, then words.
+    """
+    if len(text) <= max_length:
+        return [text]
+
+    chunks: list[str] = []
+    remaining = text
+
+    while remaining:
+        if len(remaining) <= max_length:
+            chunks.append(remaining)
+            break
+
+        # Find a good split point
+        split_at = max_length
+
+        # Try to split at paragraph boundary
+        para_break = remaining.rfind("\n\n", 0, max_length)
+        if para_break > max_length // 2:
+            split_at = para_break + 2
+        else:
+            # Try to split at line boundary
+            line_break = remaining.rfind("\n", 0, max_length)
+            if line_break > max_length // 2:
+                split_at = line_break + 1
+            else:
+                # Try to split at sentence boundary
+                for sep in (". ", "! ", "? "):
+                    sent_break = remaining.rfind(sep, 0, max_length)
+                    if sent_break > max_length // 2:
+                        split_at = sent_break + len(sep)
+                        break
+                else:
+                    # Try to split at word boundary
+                    word_break = remaining.rfind(" ", 0, max_length)
+                    if word_break > max_length // 2:
+                        split_at = word_break + 1
+
+        chunks.append(remaining[:split_at].rstrip())
+        remaining = remaining[split_at:].lstrip()
+
+    return chunks
+
+
+def create_paginated_embeds(
+    title: str,
+    content: str,
+    *,
+    color: int = 0xE6E6FA,
+    max_length: int = 4000,
+    footer_prefix: str = "",
+) -> list[disnake.Embed]:
+    """Create a list of embeds from long content."""
+    chunks = paginate_text(content, max_length)
+
+    if len(chunks) == 1:
+        embed = disnake.Embed(title=title, description=chunks[0], color=color)
+        if footer_prefix:
+            embed.set_footer(text=footer_prefix)
+        return [embed]
+
+    embeds: list[disnake.Embed] = []
+    for i, chunk in enumerate(chunks, 1):
+        embed = disnake.Embed(
+            title=f"{title} ({i}/{len(chunks)})" if len(chunks) > 1 else title,
+            description=chunk,
+            color=color,
+        )
+        footer = f"Page {i}/{len(chunks)}"
+        if footer_prefix:
+            footer = f"{footer_prefix} · {footer}"
+        embed.set_footer(text=footer)
+        embeds.append(embed)
+
+    return embeds
+
+
+async def send_paginated(
+    target: disnake.abc.Messageable | disnake.Interaction,
+    embeds: list[disnake.Embed],
+    *,
+    author_id: int | None = None,
+    ephemeral: bool = False,
+) -> disnake.Message | None:
+    """Send paginated embeds with navigation buttons if needed."""
+    if not embeds:
+        return None
+
+    if len(embeds) == 1:
+        # Single page, no pagination needed
+        if isinstance(target, disnake.Interaction):
+            if target.response.is_done():
+                return await target.edit_original_response(embed=embeds[0])
+            await target.response.send_message(embed=embeds[0], ephemeral=ephemeral)
+            return await target.original_response()
+        return await target.send(embed=embeds[0])
+
+    # Multiple pages, use paginator
+    view = Paginator(embeds, author_id=author_id)
+    view.update_page_indicator()
+
+    if isinstance(target, disnake.Interaction):
+        if target.response.is_done():
+            return await target.edit_original_response(embed=embeds[0], view=view)
+        await target.response.send_message(
+            embed=embeds[0], view=view, ephemeral=ephemeral
+        )
+        return await target.original_response()
+
+    return await target.send(embed=embeds[0], view=view)

discord_bot/src/views.py

@@ -0,0 +1,294 @@
+"""Discord UI components for summarization commands."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Callable, Coroutine
+
+import disnake
+from loguru import logger
+
+from sdk import LlmInfo, SummarizerClient
+
+if TYPE_CHECKING:
+    from src.bot import SummarizerBot
+
+
+class ProviderSelect(disnake.ui.StringSelect):
+    """Dropdown for selecting LLM provider."""
+
+    def __init__(self, selected: str = "lmstudio") -> None:
+        options = [
+            disnake.SelectOption(
+                label="Anthropic (Claude)",
+                value="anthropic",
+                description="Claude AI models",
+                emoji="🤖",
+                default=(selected == "anthropic"),
+            ),
+            disnake.SelectOption(
+                label="Ollama",
+                value="ollama",
+                description="Local Ollama models",
+                emoji="🦙",
+                default=(selected == "ollama"),
+            ),
+            disnake.SelectOption(
+                label="LM Studio",
+                value="lmstudio",
+                description="Local LM Studio models",
+                emoji="💻",
+                default=(selected == "lmstudio"),
+            ),
+        ]
+        super().__init__(
+            placeholder="Select AI Provider",
+            options=options,
+            custom_id="provider_select",
+        )
+
+    async def callback(self, inter: disnake.MessageInteraction) -> None:
+        """Handle provider selection - triggers model list refresh."""
+        # The view will handle this
+        self.view.selected_provider = self.values[0]  # type: ignore[union-attr]
+        await self.view.refresh_models(inter)  # type: ignore[union-attr]
+
+
+class ModelSelect(disnake.ui.StringSelect):
+    """Dropdown for selecting LLM model."""
+
+    def __init__(self, models: list[LlmInfo] | None = None) -> None:
+        if models:
+            options = [
+                disnake.SelectOption(
+                    label=m.model[:100],
+                    value=m.model,
+                    description=f"{m.provider}"
+                    + (f" v{m.version}" if m.version else ""),  # noqa: E501
+                )
+                for m in models[:25]  # Discord limit
+            ]
+        else:
+            options = [
+                disnake.SelectOption(
+                    label="Select provider first",
+                    value="none",
+                    description="Choose a provider to see available models",
+                )
+            ]
+        super().__init__(
+            placeholder="Select Model (optional)",
+            options=options,
+            custom_id="model_select",
+            disabled=not models,
+        )
+
+    async def callback(self, inter: disnake.MessageInteraction) -> None:
+        """Handle model selection."""
+        self.view.selected_model = self.values[0] if self.values[0] != "none" else None  # type: ignore[union-attr]
+        await inter.response.defer()
+
+
+class ProviderModelView(disnake.ui.View):
+    """View for selecting provider and model before summarization."""
+
+    def __init__(
+        self,
+        bot: SummarizerBot,
+        on_confirm: Callable[[str, str | None], Coroutine[Any, Any, None]],
+        *,
+        timeout: float = 120.0,
+        author_id: int,
+    ) -> None:
+        super().__init__(timeout=timeout)
+        self.bot = bot
+        self.on_confirm = on_confirm
+        self.author_id = author_id
+        self.selected_provider: str = "lmstudio"
+        self.selected_model: str | None = None
+        self._models_cache: dict[str, list[LlmInfo]] = {}
+
+        # Add components
+        self.provider_select = ProviderSelect()
+        self.model_select = ModelSelect()
+        self.add_item(self.provider_select)
+        self.add_item(self.model_select)
+
+    async def interaction_check(  # type: ignore[override]
+        self, interaction: disnake.MessageInteraction
+    ) -> bool:
+        """Only allow the command author to interact."""
+        if interaction.author.id != self.author_id:
+            await interaction.response.send_message(
+                "Only the command author can use these controls.", ephemeral=True
+            )
+            return False
+        return True
+
+    async def fetch_models(self) -> list[LlmInfo]:
+        """Fetch available models from API."""
+        try:
+            async with SummarizerClient(base_url=self.bot.config.bot.api_url) as client:
+                return await client.list_models()
+        except Exception as e:  # noqa: BLE001
+            logger.warning(f"Failed to fetch models: {e}")
+            return []
+
+    async def prefetch_models(self) -> None:
+        """Prefetch and cache all models."""
+        if not self._models_cache:
+            all_models = await self.fetch_models()
+            for model in all_models:
+                provider = model.provider.lower()
+                if provider not in self._models_cache:
+                    self._models_cache[provider] = []
+                self._models_cache[provider].append(model)
+
+    def get_provider_models(self, provider: str) -> list[LlmInfo]:
+        """Get available models for a specific provider."""
+        return [m for m in self._models_cache.get(provider, []) if m.available]
+
+    async def refresh_models(self, inter: disnake.MessageInteraction) -> None:
+        """Refresh model list based on selected provider."""
+        await inter.response.defer()
+
+        # Fetch models if not cached
+        if not self._models_cache:
+            all_models = await self.fetch_models()
+            for model in all_models:
+                provider = model.provider.lower()
+                if provider not in self._models_cache:
+                    self._models_cache[provider] = []
+                self._models_cache[provider].append(model)
+
+        # Filter models for selected provider
+        provider_models = self._models_cache.get(self.selected_provider, [])
+        available_models = [m for m in provider_models if m.available]
+
+        # Update provider select to show current selection
+        self.remove_item(self.provider_select)
+        self.provider_select = ProviderSelect(selected=self.selected_provider)
+        self.add_item(self.provider_select)
+
+        # Update model select
+        self.remove_item(self.model_select)
+        self.model_select = ModelSelect(available_models if available_models else None)
+        self.add_item(self.model_select)
+        self.selected_model = None
+
+        await inter.edit_original_response(view=self)
+
+    @disnake.ui.button(label="Use Defaults", style=disnake.ButtonStyle.secondary, row=2)
+    async def use_defaults(
+        self, _button: disnake.ui.Button, _inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Use default provider and model."""
+        self.stop()
+        await self.on_confirm("lmstudio", None)
+
+    @disnake.ui.button(label="Confirm", style=disnake.ButtonStyle.primary, row=2)
+    async def confirm(
+        self, _button: disnake.ui.Button, _inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Confirm selection and proceed."""
+        self.stop()
+        await self.on_confirm(self.selected_provider, self.selected_model)
+
+    @disnake.ui.button(label="Cancel", style=disnake.ButtonStyle.danger, row=2)
+    async def cancel(
+        self, _button: disnake.ui.Button, inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Cancel the operation."""
+        self.stop()
+        await inter.response.edit_message(
+            content="Operation cancelled.", embed=None, view=None
+        )
+
+
+class QuickSummarizeView(disnake.ui.View):
+    """View with quick summarize button and advanced options."""
+
+    def __init__(
+        self,
+        bot: SummarizerBot,
+        summarize_callback: Callable[[str, str | None], Coroutine[Any, Any, None]],
+        *,
+        timeout: float = 60.0,
+        author_id: int,
+    ) -> None:
+        super().__init__(timeout=timeout)
+        self.bot = bot
+        self.summarize_callback = summarize_callback
+        self.author_id = author_id
+
+    async def interaction_check(  # type: ignore[override]
+        self, interaction: disnake.MessageInteraction
+    ) -> bool:
+        """Only allow the command author to interact."""
+        if interaction.author.id != self.author_id:
+            await interaction.response.send_message(
+                "Only the command author can use these controls.", ephemeral=True
+            )
+            return False
+        return True
+
+    @disnake.ui.button(
+        label="Summarize (Default)", style=disnake.ButtonStyle.primary, emoji="⚡"
+    )
+    async def quick_summarize(
+        self, _button: disnake.ui.Button, inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Quick summarize with defaults."""
+        self.stop()
+        await inter.response.defer()
+        await self.summarize_callback("lmstudio", None)
+
+    @disnake.ui.button(
+        label="Choose Provider/Model", style=disnake.ButtonStyle.secondary, emoji="⚙️"
+    )
+    async def advanced_options(
+        self, _button: disnake.ui.Button, inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Show advanced provider/model selection."""
+        self.stop()
+
+        async def on_confirm(provider: str, model: str | None) -> None:
+            await self.summarize_callback(provider, model)
+
+        view = ProviderModelView(self.bot, on_confirm, author_id=self.author_id)
+
+        # Prefetch models
+        await view.prefetch_models()
+
+        # Set up initial model select with lmstudio models
+        lmstudio_models = view.get_provider_models("lmstudio")
+        view.remove_item(view.model_select)
+        view.model_select = ModelSelect(lmstudio_models if lmstudio_models else None)
+        view.add_item(view.model_select)
+
+        embed = disnake.Embed(
+            title="🔧 Advanced Options",
+            description="Select your preferred AI provider and model.",
+            color=disnake.Color.blurple(),
+        )
+        embed.add_field(
+            name="Provider",
+            value="Choose the AI service to use for summarization.",
+            inline=False,
+        )
+        embed.add_field(
+            name="Model",
+            value="Optionally select a specific model (leave empty for default).",
+            inline=False,
+        )
+
+        await inter.response.edit_message(embed=embed, view=view)
+
+    @disnake.ui.button(label="Cancel", style=disnake.ButtonStyle.danger, emoji="✖️")
+    async def cancel(
+        self, _button: disnake.ui.Button, inter: disnake.MessageInteraction  # type: ignore[type-arg]
+    ) -> None:
+        """Cancel the operation."""
+        self.stop()
+        await inter.response.edit_message(
+            content="Operation cancelled.", embed=None, view=None
+        )

discord_bot/uv.lock

@@ -0,0 +1,895 @@
+version = 1
+revision = 3
+requires-python = ">=3.12"
+
+[[package]]
+name = "aiohappyeyeballs"
+version = "2.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/26/30/f84a107a9c4331c14b2b586036f40965c128aa4fee4dda5d3d51cb14ad54/aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558", size = 22760, upload-time = "2025-03-12T01:42:48.764Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0f/15/5bf3b99495fb160b63f95972b81750f18f7f4e02ad051373b669d17d44f2/aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8", size = 15265, upload-time = "2025-03-12T01:42:47.083Z" },
+]
+
+[[package]]
+name = "aiohttp"
+version = "3.13.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohappyeyeballs" },
+    { name = "aiosignal" },
+    { name = "attrs" },
+    { name = "frozenlist" },
+    { name = "multidict" },
+    { name = "propcache" },
+    { name = "yarl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/fa/3ae643cd525cf6844d3dc810481e5748107368eb49563c15a5fb9f680750/aiohttp-3.13.1.tar.gz", hash = "sha256:4b7ee9c355015813a6aa085170b96ec22315dabc3d866fd77d147927000e9464", size = 7835344, upload-time = "2025-10-17T14:03:29.337Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1a/72/d463a10bf29871f6e3f63bcf3c91362dc4d72ed5917a8271f96672c415ad/aiohttp-3.13.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0760bd9a28efe188d77b7c3fe666e6ef74320d0f5b105f2e931c7a7e884c8230", size = 736218, upload-time = "2025-10-17T14:00:03.51Z" },
+    { url = "https://files.pythonhosted.org/packages/26/13/f7bccedbe52ea5a6eef1e4ebb686a8d7765319dfd0a5939f4238cb6e79e6/aiohttp-3.13.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7129a424b441c3fe018a414401bf1b9e1d49492445f5676a3aecf4f74f67fcdb", size = 491251, upload-time = "2025-10-17T14:00:05.756Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/7c/7ea51b5aed6cc69c873f62548da8345032aa3416336f2d26869d4d37b4a2/aiohttp-3.13.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:e1cb04ae64a594f6ddf5cbb024aba6b4773895ab6ecbc579d60414f8115e9e26", size = 490394, upload-time = "2025-10-17T14:00:07.504Z" },
+    { url = "https://files.pythonhosted.org/packages/31/05/1172cc4af4557f6522efdee6eb2b9f900e1e320a97e25dffd3c5a6af651b/aiohttp-3.13.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:782d656a641e755decd6bd98d61d2a8ea062fd45fd3ff8d4173605dd0d2b56a1", size = 1737455, upload-time = "2025-10-17T14:00:09.403Z" },
+    { url = "https://files.pythonhosted.org/packages/24/3d/ce6e4eca42f797d6b1cd3053cf3b0a22032eef3e4d1e71b9e93c92a3f201/aiohttp-3.13.1-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:f92ad8169767429a6d2237331726c03ccc5f245222f9373aa045510976af2b35", size = 1699176, upload-time = "2025-10-17T14:00:11.314Z" },
+    { url = "https://files.pythonhosted.org/packages/25/04/7127ba55653e04da51477372566b16ae786ef854e06222a1c96b4ba6c8ef/aiohttp-3.13.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:0e778f634ca50ec005eefa2253856921c429581422d887be050f2c1c92e5ce12", size = 1767216, upload-time = "2025-10-17T14:00:13.668Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/3b/43bca1e75847e600f40df829a6b2f0f4e1d4c70fb6c4818fdc09a462afd5/aiohttp-3.13.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:9bc36b41cf4aab5d3b34d22934a696ab83516603d1bc1f3e4ff9930fe7d245e5", size = 1865870, upload-time = "2025-10-17T14:00:15.852Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/69/b204e5d43384197a614c88c1717c324319f5b4e7d0a1b5118da583028d40/aiohttp-3.13.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:3fd4570ea696aee27204dd524f287127ed0966d14d309dc8cc440f474e3e7dbd", size = 1751021, upload-time = "2025-10-17T14:00:18.297Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/af/845dc6b6fdf378791d720364bf5150f80d22c990f7e3a42331d93b337cc7/aiohttp-3.13.1-cp312-cp312-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:7bda795f08b8a620836ebfb0926f7973972a4bf8c74fdf9145e489f88c416811", size = 1561448, upload-time = "2025-10-17T14:00:20.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/91/d2ab08cd77ed76a49e4106b1cfb60bce2768242dd0c4f9ec0cb01e2cbf94/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:055a51d90e351aae53dcf324d0eafb2abe5b576d3ea1ec03827d920cf81a1c15", size = 1698196, upload-time = "2025-10-17T14:00:22.131Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/d1/082f0620dc428ecb8f21c08a191a4694915cd50f14791c74a24d9161cc50/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:d4131df864cbcc09bb16d3612a682af0db52f10736e71312574d90f16406a867", size = 1719252, upload-time = "2025-10-17T14:00:24.453Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/78/2af2f44491be7b08e43945b72d2b4fd76f0a14ba850ba9e41d28a7ce716a/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:163d3226e043f79bf47c87f8dfc89c496cc7bc9128cb7055ce026e435d551720", size = 1736529, upload-time = "2025-10-17T14:00:26.567Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/34/3e919ecdc93edaea8d140138049a0d9126141072e519535e2efa38eb7a02/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_riscv64.whl", hash = "sha256:a2370986a3b75c1a5f3d6f6d763fc6be4b430226577b0ed16a7c13a75bf43d8f", size = 1553723, upload-time = "2025-10-17T14:00:28.592Z" },
+    { url = "https://files.pythonhosted.org/packages/21/4b/d8003aeda2f67f359b37e70a5a4b53fee336d8e89511ac307ff62aeefcdb/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:d7c14de0c7c9f1e6e785ce6cbe0ed817282c2af0012e674f45b4e58c6d4ea030", size = 1763394, upload-time = "2025-10-17T14:00:31.051Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/7b/1dbe6a39e33af9baaafc3fc016a280663684af47ba9f0e5d44249c1f72ec/aiohttp-3.13.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:bb611489cf0db10b99beeb7280bd39e0ef72bc3eb6d8c0f0a16d8a56075d1eb7", size = 1718104, upload-time = "2025-10-17T14:00:33.407Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/88/bd1b38687257cce67681b9b0fa0b16437be03383fa1be4d1a45b168bef25/aiohttp-3.13.1-cp312-cp312-win32.whl", hash = "sha256:f90fe0ee75590f7428f7c8b5479389d985d83c949ea10f662ab928a5ed5cf5e6", size = 425303, upload-time = "2025-10-17T14:00:35.829Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/e3/4481f50dd6f27e9e58c19a60cff44029641640237e35d32b04aaee8cf95f/aiohttp-3.13.1-cp312-cp312-win_amd64.whl", hash = "sha256:3461919a9dca272c183055f2aab8e6af0adc810a1b386cce28da11eb00c859d9", size = 452071, upload-time = "2025-10-17T14:00:37.764Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6d/d267b132342e1080f4c1bb7e1b4e96b168b3cbce931ec45780bff693ff95/aiohttp-3.13.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:55785a7f8f13df0c9ca30b5243d9909bd59f48b274262a8fe78cee0828306e5d", size = 730727, upload-time = "2025-10-17T14:00:39.681Z" },
+    { url = "https://files.pythonhosted.org/packages/92/c8/1cf495bac85cf71b80fad5f6d7693e84894f11b9fe876b64b0a1e7cbf32f/aiohttp-3.13.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:4bef5b83296cebb8167707b4f8d06c1805db0af632f7a72d7c5288a84667e7c3", size = 488678, upload-time = "2025-10-17T14:00:41.541Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/19/23c6b81cca587ec96943d977a58d11d05a82837022e65cd5502d665a7d11/aiohttp-3.13.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:27af0619c33f9ca52f06069ec05de1a357033449ab101836f431768ecfa63ff5", size = 487637, upload-time = "2025-10-17T14:00:43.527Z" },
+    { url = "https://files.pythonhosted.org/packages/48/58/8f9464afb88b3eed145ad7c665293739b3a6f91589694a2bb7e5778cbc72/aiohttp-3.13.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a47fe43229a8efd3764ef7728a5c1158f31cdf2a12151fe99fde81c9ac87019c", size = 1718975, upload-time = "2025-10-17T14:00:45.496Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/8b/c3da064ca392b2702f53949fd7c403afa38d9ee10bf52c6ad59a42537103/aiohttp-3.13.1-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:6e68e126de5b46e8b2bee73cab086b5d791e7dc192056916077aa1e2e2b04437", size = 1686905, upload-time = "2025-10-17T14:00:47.707Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/a4/9c8a3843ecf526daee6010af1a66eb62579be1531d2d5af48ea6f405ad3c/aiohttp-3.13.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:e65ef49dd22514329c55970d39079618a8abf856bae7147913bb774a3ab3c02f", size = 1754907, upload-time = "2025-10-17T14:00:49.702Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/80/1f470ed93e06436e3fc2659a9fc329c192fa893fb7ed4e884d399dbfb2a8/aiohttp-3.13.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e425a7e0511648b3376839dcc9190098671a47f21a36e815b97762eb7d556b0", size = 1857129, upload-time = "2025-10-17T14:00:51.822Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/e6/33d305e6cce0a8daeb79c7d8d6547d6e5f27f4e35fa4883fc9c9eb638596/aiohttp-3.13.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:010dc9b7110f055006acd3648d5d5955bb6473b37c3663ec42a1b4cba7413e6b", size = 1738189, upload-time = "2025-10-17T14:00:53.976Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/42/8df03367e5a64327fe0c39291080697795430c438fc1139c7cc1831aa1df/aiohttp-3.13.1-cp313-cp313-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:1b5c722d0ca5f57d61066b5dfa96cdb87111e2519156b35c1f8dd17c703bee7a", size = 1553608, upload-time = "2025-10-17T14:00:56.144Z" },
+    { url = "https://files.pythonhosted.org/packages/96/17/6d5c73cd862f1cf29fddcbb54aac147037ff70a043a2829d03a379e95742/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:93029f0e9b77b714904a281b5aa578cdc8aa8ba018d78c04e51e1c3d8471b8ec", size = 1681809, upload-time = "2025-10-17T14:00:58.603Z" },
+    { url = "https://files.pythonhosted.org/packages/be/31/8926c8ab18533f6076ce28d2c329a203b58c6861681906e2d73b9c397588/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:d1824c7d08d8ddfc8cb10c847f696942e5aadbd16fd974dfde8bd2c3c08a9fa1", size = 1711161, upload-time = "2025-10-17T14:01:01.744Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/36/2f83e1ca730b1e0a8cf1c8ab9559834c5eec9f5da86e77ac71f0d16b521d/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:8f47d0ff5b3eb9c1278a2f56ea48fda667da8ebf28bd2cb378b7c453936ce003", size = 1731999, upload-time = "2025-10-17T14:01:04.626Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ec/1f818cc368dfd4d5ab4e9efc8f2f6f283bfc31e1c06d3e848bcc862d4591/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_riscv64.whl", hash = "sha256:8a396b1da9b51ded79806ac3b57a598f84e0769eaa1ba300655d8b5e17b70c7b", size = 1548684, upload-time = "2025-10-17T14:01:06.828Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/ad/33d36efd16e4fefee91b09a22a3a0e1b830f65471c3567ac5a8041fac812/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:d9c52a65f54796e066b5d674e33b53178014752d28bca555c479c2c25ffcec5b", size = 1756676, upload-time = "2025-10-17T14:01:09.517Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/c4/4a526d84e77d464437713ca909364988ed2e0cd0cdad2c06cb065ece9e08/aiohttp-3.13.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a89da72d18d6c95a653470b78d8ee5aa3c4b37212004c103403d0776cbea6ff0", size = 1715577, upload-time = "2025-10-17T14:01:11.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/21/e39638b7d9c7f1362c4113a91870f89287e60a7ea2d037e258b81e8b37d5/aiohttp-3.13.1-cp313-cp313-win32.whl", hash = "sha256:02e0258b7585ddf5d01c79c716ddd674386bfbf3041fbbfe7bdf9c7c32eb4a9b", size = 424468, upload-time = "2025-10-17T14:01:14.344Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/00/f3a92c592a845ebb2f47d102a67f35f0925cb854c5e7386f1a3a1fdff2ab/aiohttp-3.13.1-cp313-cp313-win_amd64.whl", hash = "sha256:ef56ffe60e8d97baac123272bde1ab889ee07d3419606fae823c80c2b86c403e", size = 450806, upload-time = "2025-10-17T14:01:16.437Z" },
+    { url = "https://files.pythonhosted.org/packages/97/be/0f6c41d2fd0aab0af133c509cabaf5b1d78eab882cb0ceb872e87ceeabf7/aiohttp-3.13.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:77f83b3dc5870a2ea79a0fcfdcc3fc398187ec1675ff61ec2ceccad27ecbd303", size = 733828, upload-time = "2025-10-17T14:01:18.58Z" },
+    { url = "https://files.pythonhosted.org/packages/75/14/24e2ac5efa76ae30e05813e0f50737005fd52da8ddffee474d4a5e7f38a6/aiohttp-3.13.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:9cafd2609ebb755e47323306c7666283fbba6cf82b5f19982ea627db907df23a", size = 489320, upload-time = "2025-10-17T14:01:20.644Z" },
+    { url = "https://files.pythonhosted.org/packages/da/5a/4cbe599358d05ea7db4869aff44707b57d13f01724d48123dc68b3288d5a/aiohttp-3.13.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9c489309a2ca548d5f11131cfb4092f61d67954f930bba7e413bcdbbb82d7fae", size = 489899, upload-time = "2025-10-17T14:01:22.638Z" },
+    { url = "https://files.pythonhosted.org/packages/67/96/3aec9d9cfc723273d4386328a1e2562cf23629d2f57d137047c49adb2afb/aiohttp-3.13.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:79ac15fe5fdbf3c186aa74b656cd436d9a1e492ba036db8901c75717055a5b1c", size = 1716556, upload-time = "2025-10-17T14:01:25.406Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/99/39a3d250595b5c8172843831221fa5662884f63f8005b00b4034f2a7a836/aiohttp-3.13.1-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:095414be94fce3bc080684b4cd50fb70d439bc4662b2a1984f45f3bf9ede08aa", size = 1665814, upload-time = "2025-10-17T14:01:27.683Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/96/8319e7060a85db14a9c178bc7b3cf17fad458db32ba6d2910de3ca71452d/aiohttp-3.13.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c68172e1a2dca65fa1272c85ca72e802d78b67812b22827df01017a15c5089fa", size = 1755767, upload-time = "2025-10-17T14:01:29.914Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/c6/0a2b3d886b40aa740fa2294cd34ed46d2e8108696748492be722e23082a7/aiohttp-3.13.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3751f9212bcd119944d4ea9de6a3f0fee288c177b8ca55442a2cdff0c8201eb3", size = 1836591, upload-time = "2025-10-17T14:01:32.28Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/34/8ab5904b3331c91a58507234a1e2f662f837e193741609ee5832eb436251/aiohttp-3.13.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8619dca57d98a8353abdc7a1eeb415548952b39d6676def70d9ce76d41a046a9", size = 1714915, upload-time = "2025-10-17T14:01:35.138Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/d3/d36077ca5f447649112189074ac6c192a666bf68165b693e48c23b0d008c/aiohttp-3.13.1-cp314-cp314-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:97795a0cb0a5f8a843759620e9cbd8889f8079551f5dcf1ccd99ed2f056d9632", size = 1546579, upload-time = "2025-10-17T14:01:38.237Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/14/dbc426a1bb1305c4fc78ce69323498c9e7c699983366ef676aa5d3f949fa/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:1060e058da8f9f28a7026cdfca9fc886e45e551a658f6a5c631188f72a3736d2", size = 1680633, upload-time = "2025-10-17T14:01:40.902Z" },
+    { url = "https://files.pythonhosted.org/packages/29/83/1e68e519aff9f3ef6d4acb6cdda7b5f592ef5c67c8f095dc0d8e06ce1c3e/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:f48a2c26333659101ef214907d29a76fe22ad7e912aa1e40aeffdff5e8180977", size = 1678675, upload-time = "2025-10-17T14:01:43.779Z" },
+    { url = "https://files.pythonhosted.org/packages/38/b9/7f3e32a81c08b6d29ea15060c377e1f038ad96cd9923a85f30e817afff22/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:f1dfad638b9c91ff225162b2824db0e99ae2d1abe0dc7272b5919701f0a1e685", size = 1726829, upload-time = "2025-10-17T14:01:46.546Z" },
+    { url = "https://files.pythonhosted.org/packages/23/ce/610b1f77525a0a46639aea91377b12348e9f9412cc5ddcb17502aa4681c7/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_riscv64.whl", hash = "sha256:8fa09ab6dd567cb105db4e8ac4d60f377a7a94f67cf669cac79982f626360f32", size = 1542985, upload-time = "2025-10-17T14:01:49.082Z" },
+    { url = "https://files.pythonhosted.org/packages/53/39/3ac8dfdad5de38c401846fa071fcd24cb3b88ccfb024854df6cbd9b4a07e/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4159fae827f9b5f655538a4f99b7cbc3a2187e5ca2eee82f876ef1da802ccfa9", size = 1741556, upload-time = "2025-10-17T14:01:51.846Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/48/b1948b74fea7930b0f29595d1956842324336de200593d49a51a40607fdc/aiohttp-3.13.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:ad671118c19e9cfafe81a7a05c294449fe0ebb0d0c6d5bb445cd2190023f5cef", size = 1696175, upload-time = "2025-10-17T14:01:54.232Z" },
+    { url = "https://files.pythonhosted.org/packages/96/26/063bba38e4b27b640f56cc89fe83cc3546a7ae162c2e30ca345f0ccdc3d1/aiohttp-3.13.1-cp314-cp314-win32.whl", hash = "sha256:c5c970c148c48cf6acb65224ca3c87a47f74436362dde75c27bc44155ccf7dfc", size = 430254, upload-time = "2025-10-17T14:01:56.451Z" },
+    { url = "https://files.pythonhosted.org/packages/88/aa/25fd764384dc4eab714023112d3548a8dd69a058840d61d816ea736097a2/aiohttp-3.13.1-cp314-cp314-win_amd64.whl", hash = "sha256:748a00167b7a88385756fa615417d24081cba7e58c8727d2e28817068b97c18c", size = 456256, upload-time = "2025-10-17T14:01:58.752Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/9f/9ba6059de4bad25c71cd88e3da53f93e9618ea369cf875c9f924b1c167e2/aiohttp-3.13.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:390b73e99d7a1f0f658b3f626ba345b76382f3edc65f49d6385e326e777ed00e", size = 765956, upload-time = "2025-10-17T14:02:01.515Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/30/b86da68b494447d3060f45c7ebb461347535dab4af9162a9267d9d86ca31/aiohttp-3.13.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e83abb330e687e019173d8fc1fd6a1cf471769624cf89b1bb49131198a810a", size = 503206, upload-time = "2025-10-17T14:02:03.818Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/21/d27a506552843ff9eeb9fcc2d45f943b09eefdfdf205aab044f4f1f39f6a/aiohttp-3.13.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2b20eed07131adbf3e873e009c2869b16a579b236e9d4b2f211bf174d8bef44a", size = 507719, upload-time = "2025-10-17T14:02:05.947Z" },
+    { url = "https://files.pythonhosted.org/packages/58/23/4042230ec7e4edc7ba43d0342b5a3d2fe0222ca046933c4251a35aaf17f5/aiohttp-3.13.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:58fee9ef8477fd69e823b92cfd1f590ee388521b5ff8f97f3497e62ee0656212", size = 1862758, upload-time = "2025-10-17T14:02:08.469Z" },
+    { url = "https://files.pythonhosted.org/packages/df/88/525c45bea7cbb9f65df42cadb4ff69f6a0dbf95931b0ff7d1fdc40a1cb5f/aiohttp-3.13.1-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:1f62608fcb7b3d034d5e9496bea52d94064b7b62b06edba82cd38191336bbeda", size = 1717790, upload-time = "2025-10-17T14:02:11.37Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/80/21e9b5eb77df352a5788713f37359b570a793f0473f3a72db2e46df379b9/aiohttp-3.13.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fdc4d81c3dfc999437f23e36d197e8b557a3f779625cd13efe563a9cfc2ce712", size = 1842088, upload-time = "2025-10-17T14:02:13.872Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/bf/d1738f6d63fe8b2a0ad49533911b3347f4953cd001bf3223cb7b61f18dff/aiohttp-3.13.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:601d7ec812f746fd80ff8af38eeb3f196e1bab4a4d39816ccbc94c222d23f1d0", size = 1934292, upload-time = "2025-10-17T14:02:16.624Z" },
+    { url = "https://files.pythonhosted.org/packages/04/e6/26cab509b42610ca49573f2fc2867810f72bd6a2070182256c31b14f2e98/aiohttp-3.13.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47c3f21c469b840d9609089435c0d9918ae89f41289bf7cc4afe5ff7af5458db", size = 1791328, upload-time = "2025-10-17T14:02:19.051Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/6d/baf7b462852475c9d045bee8418d9cdf280efb687752b553e82d0c58bcc2/aiohttp-3.13.1-cp314-cp314t-manylinux_2_31_riscv64.manylinux_2_39_riscv64.whl", hash = "sha256:d6c6cdc0750db88520332d4aaa352221732b0cafe89fd0e42feec7cb1b5dc236", size = 1622663, upload-time = "2025-10-17T14:02:21.397Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/48/396a97318af9b5f4ca8b3dc14a67976f71c6400a9609c622f96da341453f/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:58a12299eeb1fca2414ee2bc345ac69b0f765c20b82c3ab2a75d91310d95a9f6", size = 1787791, upload-time = "2025-10-17T14:02:24.212Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/e2/6925f6784134ce3ff3ce1a8502ab366432a3b5605387618c1a939ce778d9/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:0989cbfc195a4de1bb48f08454ef1cb47424b937e53ed069d08404b9d3c7aea1", size = 1775459, upload-time = "2025-10-17T14:02:26.971Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/e3/b372047ba739fc39f199b99290c4cc5578ce5fd125f69168c967dac44021/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:feb5ee664300e2435e0d1bc3443a98925013dfaf2cae9699c1f3606b88544898", size = 1789250, upload-time = "2025-10-17T14:02:29.686Z" },
+    { url = "https://files.pythonhosted.org/packages/02/8c/9f48b93d7d57fc9ef2ad4adace62e4663ea1ce1753806c4872fb36b54c39/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_riscv64.whl", hash = "sha256:58a6f8702da0c3606fb5cf2e669cce0ca681d072fe830968673bb4c69eb89e88", size = 1616139, upload-time = "2025-10-17T14:02:32.151Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/c6/c64e39d61aaa33d7de1be5206c0af3ead4b369bf975dac9fdf907a4291c1/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:a417ceb433b9d280e2368ffea22d4bc6e3e0d894c4bc7768915124d57d0964b6", size = 1815829, upload-time = "2025-10-17T14:02:34.635Z" },
+    { url = "https://files.pythonhosted.org/packages/22/75/e19e93965ea675f1151753b409af97a14f1d888588a555e53af1e62b83eb/aiohttp-3.13.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:8ac8854f7b0466c5d6a9ea49249b3f6176013859ac8f4bb2522ad8ed6b94ded2", size = 1760923, upload-time = "2025-10-17T14:02:37.364Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/a4/06ed38f1dabd98ea136fd116cba1d02c9b51af5a37d513b6850a9a567d86/aiohttp-3.13.1-cp314-cp314t-win32.whl", hash = "sha256:be697a5aeff42179ed13b332a411e674994bcd406c81642d014ace90bf4bb968", size = 463318, upload-time = "2025-10-17T14:02:39.924Z" },
+    { url = "https://files.pythonhosted.org/packages/04/0f/27e4fdde899e1e90e35eeff56b54ed63826435ad6cdb06b09ed312d1b3fa/aiohttp-3.13.1-cp314-cp314t-win_amd64.whl", hash = "sha256:f1d6aa90546a4e8f20c3500cb68ab14679cd91f927fa52970035fd3207dfb3da", size = 496721, upload-time = "2025-10-17T14:02:42.199Z" },
+]
+
+[[package]]
+name = "aiosignal"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "frozenlist" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/62/06741b579156360248d1ec624842ad0edf697050bbaf7c3e46394e106ad1/aiosignal-1.4.0.tar.gz", hash = "sha256:f47eecd9468083c2029cc99945502cb7708b082c232f9aca65da147157b251c7", size = 25007, upload-time = "2025-07-03T22:54:43.528Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/76/641ae371508676492379f16e2fa48f4e2c11741bd63c48be4b12a6b09cba/aiosignal-1.4.0-py3-none-any.whl", hash = "sha256:053243f8b92b990551949e63930a839ff0cf0b0ebbe0597b0f3fb19e1a0fe82e", size = 7490, upload-time = "2025-07-03T22:54:42.156Z" },
+]
+
+[[package]]
+name = "annotated-types"
+version = "0.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ee/67/531ea369ba64dcff5ec9c3402f9f51bf748cec26dde048a2f973a4eea7f5/annotated_types-0.7.0.tar.gz", hash = "sha256:aff07c09a53a08bc8cfccb9c85b05f1aa9a2a6f23728d790723543408344ce89", size = 16081, upload-time = "2024-05-20T21:33:25.928Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/78/b6/6307fbef88d9b5ee7421e68d78a9f162e0da4900bc5f5793f6d3d0e34fb8/annotated_types-0.7.0-py3-none-any.whl", hash = "sha256:1f02e8b43a8fbbc3f3e0d4f0f4bfc8131bcb4eebe8849b8e5c773f3a1c582a53", size = 13643, upload-time = "2024-05-20T21:33:24.1Z" },
+]
+
+[[package]]
+name = "anyio"
+version = "4.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "sniffio" },
+    { name = "typing-extensions", marker = "python_full_version < '3.13'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/78/7d432127c41b50bccba979505f272c16cbcadcc33645d5fa3a738110ae75/anyio-4.11.0.tar.gz", hash = "sha256:82a8d0b81e318cc5ce71a5f1f8b5c4e63619620b63141ef8c995fa0db95a57c4", size = 219094, upload-time = "2025-09-23T09:19:12.58Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/15/b3/9b1a8074496371342ec1e796a96f99c82c945a339cd81a8e73de28b4cf9e/anyio-4.11.0-py3-none-any.whl", hash = "sha256:0287e96f4d26d4149305414d4e3bc32f0dcd0862365a4bddea19d7a1ec38c4fc", size = 109097, upload-time = "2025-09-23T09:19:10.601Z" },
+]
+
+[[package]]
+name = "attrs"
+version = "25.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/5c/685e6633917e101e5dcb62b9dd76946cbb57c26e133bae9e0cd36033c0a9/attrs-25.4.0.tar.gz", hash = "sha256:16d5969b87f0859ef33a48b35d55ac1be6e42ae49d5e853b597db70c35c57e11", size = 934251, upload-time = "2025-10-06T13:54:44.725Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/2a/7cc015f5b9f5db42b7d48157e23356022889fc354a2813c15934b7cb5c0e/attrs-25.4.0-py3-none-any.whl", hash = "sha256:adcf7e2a1fb3b36ac48d97835bb6d8ade15b8dcce26aba8bf1d14847b57a3373", size = 67615, upload-time = "2025-10-06T13:54:43.17Z" },
+]
+
+[[package]]
+name = "black"
+version = "25.9.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "pytokens" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4b/43/20b5c90612d7bdb2bdbcceeb53d588acca3bb8f0e4c5d5c751a2c8fdd55a/black-25.9.0.tar.gz", hash = "sha256:0474bca9a0dd1b51791fcc507a4e02078a1c63f6d4e4ae5544b9848c7adfb619", size = 648393, upload-time = "2025-09-19T00:27:37.758Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fb/8e/319cfe6c82f7e2d5bfb4d3353c6cc85b523d677ff59edc61fdb9ee275234/black-25.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:1b9dc70c21ef8b43248f1d86aedd2aaf75ae110b958a7909ad8463c4aa0880b0", size = 1742012, upload-time = "2025-09-19T00:33:08.678Z" },
+    { url = "https://files.pythonhosted.org/packages/94/cc/f562fe5d0a40cd2a4e6ae3f685e4c36e365b1f7e494af99c26ff7f28117f/black-25.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8e46eecf65a095fa62e53245ae2795c90bdecabd53b50c448d0a8bcd0d2e74c4", size = 1581421, upload-time = "2025-09-19T00:35:25.937Z" },
+    { url = "https://files.pythonhosted.org/packages/84/67/6db6dff1ebc8965fd7661498aea0da5d7301074b85bba8606a28f47ede4d/black-25.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9101ee58ddc2442199a25cb648d46ba22cd580b00ca4b44234a324e3ec7a0f7e", size = 1655619, upload-time = "2025-09-19T00:30:49.241Z" },
+    { url = "https://files.pythonhosted.org/packages/10/10/3faef9aa2a730306cf469d76f7f155a8cc1f66e74781298df0ba31f8b4c8/black-25.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:77e7060a00c5ec4b3367c55f39cf9b06e68965a4f2e61cecacd6d0d9b7ec945a", size = 1342481, upload-time = "2025-09-19T00:31:29.625Z" },
+    { url = "https://files.pythonhosted.org/packages/48/99/3acfea65f5e79f45472c45f87ec13037b506522719cd9d4ac86484ff51ac/black-25.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:0172a012f725b792c358d57fe7b6b6e8e67375dd157f64fa7a3097b3ed3e2175", size = 1742165, upload-time = "2025-09-19T00:34:10.402Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/18/799285282c8236a79f25d590f0222dbd6850e14b060dfaa3e720241fd772/black-25.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3bec74ee60f8dfef564b573a96b8930f7b6a538e846123d5ad77ba14a8d7a64f", size = 1581259, upload-time = "2025-09-19T00:32:49.685Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ce/883ec4b6303acdeca93ee06b7622f1fa383c6b3765294824165d49b1a86b/black-25.9.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b756fc75871cb1bcac5499552d771822fd9db5a2bb8db2a7247936ca48f39831", size = 1655583, upload-time = "2025-09-19T00:30:44.505Z" },
+    { url = "https://files.pythonhosted.org/packages/21/17/5c253aa80a0639ccc427a5c7144534b661505ae2b5a10b77ebe13fa25334/black-25.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:846d58e3ce7879ec1ffe816bb9df6d006cd9590515ed5d17db14e17666b2b357", size = 1343428, upload-time = "2025-09-19T00:32:13.839Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/46/863c90dcd3f9d41b109b7f19032ae0db021f0b2a81482ba0a1e28c84de86/black-25.9.0-py3-none-any.whl", hash = "sha256:474b34c1342cdc157d307b56c4c65bce916480c4a8f6551fdc6bf9b486a7c4ae", size = 203363, upload-time = "2025-09-19T00:27:35.724Z" },
+]
+
+[[package]]
+name = "certifi"
+version = "2025.10.5"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/4c/5b/b6ce21586237c77ce67d01dc5507039d444b630dd76611bbca2d8e5dcd91/certifi-2025.10.5.tar.gz", hash = "sha256:47c09d31ccf2acf0be3f701ea53595ee7e0b8fa08801c6624be771df09ae7b43", size = 164519, upload-time = "2025-10-05T04:12:15.808Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e4/37/af0d2ef3967ac0d6113837b44a4f0bfe1328c2b9763bd5b1744520e5cfed/certifi-2025.10.5-py3-none-any.whl", hash = "sha256:0f212c2744a9bb6de0c56639a6f68afe01ecd92d91f14ae897c4fe7bbeeef0de", size = 163286, upload-time = "2025-10-05T04:12:14.03Z" },
+]
+
+[[package]]
+name = "click"
+version = "8.3.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/46/61/de6cd827efad202d7057d93e0fed9294b96952e188f7384832791c7b2254/click-8.3.0.tar.gz", hash = "sha256:e7b8232224eba16f4ebe410c25ced9f7875cb5f3263ffc93cc3e8da705e229c4", size = 276943, upload-time = "2025-09-18T17:32:23.696Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/db/d3/9dcc0f5797f070ec8edf30fbadfb200e71d9db6b84d211e3b2085a7589a0/click-8.3.0-py3-none-any.whl", hash = "sha256:9b9f285302c6e3064f4330c05f05b81945b2a39544279343e6e7c5f27a9baddc", size = 107295, upload-time = "2025-09-18T17:32:22.42Z" },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
+]
+
+[[package]]
+name = "discord-bot"
+version = "0.1.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "attrs" },
+    { name = "disnake" },
+    { name = "httpx" },
+    { name = "loguru" },
+    { name = "pydantic" },
+]
+
+[package.dev-dependencies]
+dev = [
+    { name = "black" },
+    { name = "isort" },
+    { name = "pyright" },
+    { name = "ruff" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "attrs", specifier = "==25.4.0" },
+    { name = "disnake", specifier = "==2.11.0" },
+    { name = "httpx", specifier = "==0.28.1" },
+    { name = "loguru", specifier = "==0.7.3" },
+    { name = "pydantic", specifier = "==2.12.3" },
+]
+
+[package.metadata.requires-dev]
+dev = [
+    { name = "black", specifier = "==25.9.0" },
+    { name = "isort", specifier = "==7.0.0" },
+    { name = "pyright", specifier = "==1.1.407" },
+    { name = "ruff", specifier = "==0.14.3" },
+]
+
+[[package]]
+name = "disnake"
+version = "2.11.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ac/7f/c3d6f636ee1c2926f4ad15e819b9c3f9cb4b476c7c963910ab42cc56c5a0/disnake-2.11.0.tar.gz", hash = "sha256:e5e32556a38842e51f28040d71f0649902e42160e99c44e9a2c0d171244b8674", size = 1099438, upload-time = "2025-09-11T17:39:09.853Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/10/2b/8a7e60c0772e0eae260256a090b919de1a7f4c0b897e33c34667660efb1e/disnake-2.11.0-py3-none-any.whl", hash = "sha256:50fe5f8bb5c5b568655a9ec48f647645ced9086863e285c2dc7b17424092970b", size = 1162693, upload-time = "2025-09-11T17:39:08.165Z" },
+]
+
+[[package]]
+name = "frozenlist"
+version = "1.8.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/2d/f5/c831fac6cc817d26fd54c7eaccd04ef7e0288806943f7cc5bbf69f3ac1f0/frozenlist-1.8.0.tar.gz", hash = "sha256:3ede829ed8d842f6cd48fc7081d7a41001a56f1f38603f9d49bf3020d59a31ad", size = 45875, upload-time = "2025-10-06T05:38:17.865Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/69/29/948b9aa87e75820a38650af445d2ef2b6b8a6fab1a23b6bb9e4ef0be2d59/frozenlist-1.8.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:78f7b9e5d6f2fdb88cdde9440dc147259b62b9d3b019924def9f6478be254ac1", size = 87782, upload-time = "2025-10-06T05:36:06.649Z" },
+    { url = "https://files.pythonhosted.org/packages/64/80/4f6e318ee2a7c0750ed724fa33a4bdf1eacdc5a39a7a24e818a773cd91af/frozenlist-1.8.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:229bf37d2e4acdaf808fd3f06e854a4a7a3661e871b10dc1f8f1896a3b05f18b", size = 50594, upload-time = "2025-10-06T05:36:07.69Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/94/5c8a2b50a496b11dd519f4a24cb5496cf125681dd99e94c604ccdea9419a/frozenlist-1.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f833670942247a14eafbb675458b4e61c82e002a148f49e68257b79296e865c4", size = 50448, upload-time = "2025-10-06T05:36:08.78Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/bd/d91c5e39f490a49df14320f4e8c80161cfcce09f1e2cde1edd16a551abb3/frozenlist-1.8.0-cp312-cp312-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:494a5952b1c597ba44e0e78113a7266e656b9794eec897b19ead706bd7074383", size = 242411, upload-time = "2025-10-06T05:36:09.801Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/83/f61505a05109ef3293dfb1ff594d13d64a2324ac3482be2cedc2be818256/frozenlist-1.8.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:96f423a119f4777a4a056b66ce11527366a8bb92f54e541ade21f2374433f6d4", size = 243014, upload-time = "2025-10-06T05:36:11.394Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cb/cb6c7b0f7d4023ddda30cf56b8b17494eb3a79e3fda666bf735f63118b35/frozenlist-1.8.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3462dd9475af2025c31cc61be6652dfa25cbfb56cbbf52f4ccfe029f38decaf8", size = 234909, upload-time = "2025-10-06T05:36:12.598Z" },
+    { url = "https://files.pythonhosted.org/packages/31/c5/cd7a1f3b8b34af009fb17d4123c5a778b44ae2804e3ad6b86204255f9ec5/frozenlist-1.8.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4c800524c9cd9bac5166cd6f55285957fcfc907db323e193f2afcd4d9abd69b", size = 250049, upload-time = "2025-10-06T05:36:14.065Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/2f95d3b416c584a1e7f0e1d6d31998c4a795f7544069ee2e0962a4b60740/frozenlist-1.8.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d6a5df73acd3399d893dafc71663ad22534b5aa4f94e8a2fabfe856c3c1b6a52", size = 256485, upload-time = "2025-10-06T05:36:15.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/03/024bf7720b3abaebcff6d0793d73c154237b85bdf67b7ed55e5e9596dc9a/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:405e8fe955c2280ce66428b3ca55e12b3c4e9c336fb2103a4937e891c69a4a29", size = 237619, upload-time = "2025-10-06T05:36:16.558Z" },
+    { url = "https://files.pythonhosted.org/packages/69/fa/f8abdfe7d76b731f5d8bd217827cf6764d4f1d9763407e42717b4bed50a0/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:908bd3f6439f2fef9e85031b59fd4f1297af54415fb60e4254a95f75b3cab3f3", size = 250320, upload-time = "2025-10-06T05:36:17.821Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/3c/b051329f718b463b22613e269ad72138cc256c540f78a6de89452803a47d/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:294e487f9ec720bd8ffcebc99d575f7eff3568a08a253d1ee1a0378754b74143", size = 246820, upload-time = "2025-10-06T05:36:19.046Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/ae/58282e8f98e444b3f4dd42448ff36fa38bef29e40d40f330b22e7108f565/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:74c51543498289c0c43656701be6b077f4b265868fa7f8a8859c197006efb608", size = 250518, upload-time = "2025-10-06T05:36:20.763Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/96/007e5944694d66123183845a106547a15944fbbb7154788cbf7272789536/frozenlist-1.8.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:776f352e8329135506a1d6bf16ac3f87bc25b28e765949282dcc627af36123aa", size = 239096, upload-time = "2025-10-06T05:36:22.129Z" },
+    { url = "https://files.pythonhosted.org/packages/66/bb/852b9d6db2fa40be96f29c0d1205c306288f0684df8fd26ca1951d461a56/frozenlist-1.8.0-cp312-cp312-win32.whl", hash = "sha256:433403ae80709741ce34038da08511d4a77062aa924baf411ef73d1146e74faf", size = 39985, upload-time = "2025-10-06T05:36:23.661Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/af/38e51a553dd66eb064cdf193841f16f077585d4d28394c2fa6235cb41765/frozenlist-1.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:34187385b08f866104f0c0617404c8eb08165ab1272e884abc89c112e9c00746", size = 44591, upload-time = "2025-10-06T05:36:24.958Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/06/1dc65480ab147339fecc70797e9c2f69d9cea9cf38934ce08df070fdb9cb/frozenlist-1.8.0-cp312-cp312-win_arm64.whl", hash = "sha256:fe3c58d2f5db5fbd18c2987cba06d51b0529f52bc3a6cdc33d3f4eab725104bd", size = 40102, upload-time = "2025-10-06T05:36:26.333Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/40/0832c31a37d60f60ed79e9dfb5a92e1e2af4f40a16a29abcc7992af9edff/frozenlist-1.8.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8d92f1a84bb12d9e56f818b3a746f3efba93c1b63c8387a73dde655e1e42282a", size = 85717, upload-time = "2025-10-06T05:36:27.341Z" },
+    { url = "https://files.pythonhosted.org/packages/30/ba/b0b3de23f40bc55a7057bd38434e25c34fa48e17f20ee273bbde5e0650f3/frozenlist-1.8.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96153e77a591c8adc2ee805756c61f59fef4cf4073a9275ee86fe8cba41241f7", size = 49651, upload-time = "2025-10-06T05:36:28.855Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ab/6e5080ee374f875296c4243c381bbdef97a9ac39c6e3ce1d5f7d42cb78d6/frozenlist-1.8.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f21f00a91358803399890ab167098c131ec2ddd5f8f5fd5fe9c9f2c6fcd91e40", size = 49417, upload-time = "2025-10-06T05:36:29.877Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/4e/e4691508f9477ce67da2015d8c00acd751e6287739123113a9fca6f1604e/frozenlist-1.8.0-cp313-cp313-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:fb30f9626572a76dfe4293c7194a09fb1fe93ba94c7d4f720dfae3b646b45027", size = 234391, upload-time = "2025-10-06T05:36:31.301Z" },
+    { url = "https://files.pythonhosted.org/packages/40/76/c202df58e3acdf12969a7895fd6f3bc016c642e6726aa63bd3025e0fc71c/frozenlist-1.8.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:eaa352d7047a31d87dafcacbabe89df0aa506abb5b1b85a2fb91bc3faa02d822", size = 233048, upload-time = "2025-10-06T05:36:32.531Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/c0/8746afb90f17b73ca5979c7a3958116e105ff796e718575175319b5bb4ce/frozenlist-1.8.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:03ae967b4e297f58f8c774c7eabcce57fe3c2434817d4385c50661845a058121", size = 226549, upload-time = "2025-10-06T05:36:33.706Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/eb/4c7eefc718ff72f9b6c4893291abaae5fbc0c82226a32dcd8ef4f7a5dbef/frozenlist-1.8.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:f6292f1de555ffcc675941d65fffffb0a5bcd992905015f85d0592201793e0e5", size = 239833, upload-time = "2025-10-06T05:36:34.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/4e/e5c02187cf704224f8b21bee886f3d713ca379535f16893233b9d672ea71/frozenlist-1.8.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29548f9b5b5e3460ce7378144c3010363d8035cea44bc0bf02d57f5a685e084e", size = 245363, upload-time = "2025-10-06T05:36:36.534Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/96/cb85ec608464472e82ad37a17f844889c36100eed57bea094518bf270692/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ec3cc8c5d4084591b4237c0a272cc4f50a5b03396a47d9caaf76f5d7b38a4f11", size = 229314, upload-time = "2025-10-06T05:36:38.582Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/6f/4ae69c550e4cee66b57887daeebe006fe985917c01d0fff9caab9883f6d0/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:517279f58009d0b1f2e7c1b130b377a349405da3f7621ed6bfae50b10adf20c1", size = 243365, upload-time = "2025-10-06T05:36:40.152Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/58/afd56de246cf11780a40a2c28dc7cbabbf06337cc8ddb1c780a2d97e88d8/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:db1e72ede2d0d7ccb213f218df6a078a9c09a7de257c2fe8fcef16d5925230b1", size = 237763, upload-time = "2025-10-06T05:36:41.355Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/36/cdfaf6ed42e2644740d4a10452d8e97fa1c062e2a8006e4b09f1b5fd7d63/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:b4dec9482a65c54a5044486847b8a66bf10c9cb4926d42927ec4e8fd5db7fed8", size = 240110, upload-time = "2025-10-06T05:36:42.716Z" },
+    { url = "https://files.pythonhosted.org/packages/03/a8/9ea226fbefad669f11b52e864c55f0bd57d3c8d7eb07e9f2e9a0b39502e1/frozenlist-1.8.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:21900c48ae04d13d416f0e1e0c4d81f7931f73a9dfa0b7a8746fb2fe7dd970ed", size = 233717, upload-time = "2025-10-06T05:36:44.251Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/0b/1b5531611e83ba7d13ccc9988967ea1b51186af64c42b7a7af465dcc9568/frozenlist-1.8.0-cp313-cp313-win32.whl", hash = "sha256:8b7b94a067d1c504ee0b16def57ad5738701e4ba10cec90529f13fa03c833496", size = 39628, upload-time = "2025-10-06T05:36:45.423Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/cf/174c91dbc9cc49bc7b7aab74d8b734e974d1faa8f191c74af9b7e80848e6/frozenlist-1.8.0-cp313-cp313-win_amd64.whl", hash = "sha256:878be833caa6a3821caf85eb39c5ba92d28e85df26d57afb06b35b2efd937231", size = 43882, upload-time = "2025-10-06T05:36:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/17/502cd212cbfa96eb1388614fe39a3fc9ab87dbbe042b66f97acb57474834/frozenlist-1.8.0-cp313-cp313-win_arm64.whl", hash = "sha256:44389d135b3ff43ba8cc89ff7f51f5a0bb6b63d829c8300f79a2fe4fe61bcc62", size = 39676, upload-time = "2025-10-06T05:36:47.8Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/5c/3bbfaa920dfab09e76946a5d2833a7cbdf7b9b4a91c714666ac4855b88b4/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:e25ac20a2ef37e91c1b39938b591457666a0fa835c7783c3a8f33ea42870db94", size = 89235, upload-time = "2025-10-06T05:36:48.78Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/d6/f03961ef72166cec1687e84e8925838442b615bd0b8854b54923ce5b7b8a/frozenlist-1.8.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07cdca25a91a4386d2e76ad992916a85038a9b97561bf7a3fd12d5d9ce31870c", size = 50742, upload-time = "2025-10-06T05:36:49.837Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/bb/a6d12b7ba4c3337667d0e421f7181c82dda448ce4e7ad7ecd249a16fa806/frozenlist-1.8.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4e0c11f2cc6717e0a741f84a527c52616140741cd812a50422f83dc31749fb52", size = 51725, upload-time = "2025-10-06T05:36:50.851Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/71/d1fed0ffe2c2ccd70b43714c6cab0f4188f09f8a67a7914a6b46ee30f274/frozenlist-1.8.0-cp313-cp313t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:b3210649ee28062ea6099cfda39e147fa1bc039583c8ee4481cb7811e2448c51", size = 284533, upload-time = "2025-10-06T05:36:51.898Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/1f/fb1685a7b009d89f9bf78a42d94461bc06581f6e718c39344754a5d9bada/frozenlist-1.8.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:581ef5194c48035a7de2aefc72ac6539823bb71508189e5de01d60c9dcd5fa65", size = 292506, upload-time = "2025-10-06T05:36:53.101Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/3b/b991fe1612703f7e0d05c0cf734c1b77aaf7c7d321df4572e8d36e7048c8/frozenlist-1.8.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:3ef2d026f16a2b1866e1d86fc4e1291e1ed8a387b2c333809419a2f8b3a77b82", size = 274161, upload-time = "2025-10-06T05:36:54.309Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ec/c5c618767bcdf66e88945ec0157d7f6c4a1322f1473392319b7a2501ded7/frozenlist-1.8.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5500ef82073f599ac84d888e3a8c1f77ac831183244bfd7f11eaa0289fb30714", size = 294676, upload-time = "2025-10-06T05:36:55.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/ce/3934758637d8f8a88d11f0585d6495ef54b2044ed6ec84492a91fa3b27aa/frozenlist-1.8.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:50066c3997d0091c411a66e710f4e11752251e6d2d73d70d8d5d4c76442a199d", size = 300638, upload-time = "2025-10-06T05:36:56.758Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/4f/a7e4d0d467298f42de4b41cbc7ddaf19d3cfeabaf9ff97c20c6c7ee409f9/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:5c1c8e78426e59b3f8005e9b19f6ff46e5845895adbde20ece9218319eca6506", size = 283067, upload-time = "2025-10-06T05:36:57.965Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/48/c7b163063d55a83772b268e6d1affb960771b0e203b632cfe09522d67ea5/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:eefdba20de0d938cec6a89bd4d70f346a03108a19b9df4248d3cf0d88f1b0f51", size = 292101, upload-time = "2025-10-06T05:36:59.237Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/d0/2366d3c4ecdc2fd391e0afa6e11500bfba0ea772764d631bbf82f0136c9d/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:cf253e0e1c3ceb4aaff6df637ce033ff6535fb8c70a764a8f46aafd3d6ab798e", size = 289901, upload-time = "2025-10-06T05:37:00.811Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/94/daff920e82c1b70e3618a2ac39fbc01ae3e2ff6124e80739ce5d71c9b920/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:032efa2674356903cd0261c4317a561a6850f3ac864a63fc1583147fb05a79b0", size = 289395, upload-time = "2025-10-06T05:37:02.115Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/20/bba307ab4235a09fdcd3cc5508dbabd17c4634a1af4b96e0f69bfe551ebd/frozenlist-1.8.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6da155091429aeba16851ecb10a9104a108bcd32f6c1642867eadaee401c1c41", size = 283659, upload-time = "2025-10-06T05:37:03.711Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/00/04ca1c3a7a124b6de4f8a9a17cc2fcad138b4608e7a3fc5877804b8715d7/frozenlist-1.8.0-cp313-cp313t-win32.whl", hash = "sha256:0f96534f8bfebc1a394209427d0f8a63d343c9779cda6fc25e8e121b5fd8555b", size = 43492, upload-time = "2025-10-06T05:37:04.915Z" },
+    { url = "https://files.pythonhosted.org/packages/59/5e/c69f733a86a94ab10f68e496dc6b7e8bc078ebb415281d5698313e3af3a1/frozenlist-1.8.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5d63a068f978fc69421fb0e6eb91a9603187527c86b7cd3f534a5b77a592b888", size = 48034, upload-time = "2025-10-06T05:37:06.343Z" },
+    { url = "https://files.pythonhosted.org/packages/16/6c/be9d79775d8abe79b05fa6d23da99ad6e7763a1d080fbae7290b286093fd/frozenlist-1.8.0-cp313-cp313t-win_arm64.whl", hash = "sha256:bf0a7e10b077bf5fb9380ad3ae8ce20ef919a6ad93b4552896419ac7e1d8e042", size = 41749, upload-time = "2025-10-06T05:37:07.431Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/c8/85da824b7e7b9b6e7f7705b2ecaf9591ba6f79c1177f324c2735e41d36a2/frozenlist-1.8.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:cee686f1f4cadeb2136007ddedd0aaf928ab95216e7691c63e50a8ec066336d0", size = 86127, upload-time = "2025-10-06T05:37:08.438Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/e8/a1185e236ec66c20afd72399522f142c3724c785789255202d27ae992818/frozenlist-1.8.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:119fb2a1bd47307e899c2fac7f28e85b9a543864df47aa7ec9d3c1b4545f096f", size = 49698, upload-time = "2025-10-06T05:37:09.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/93/72b1736d68f03fda5fdf0f2180fb6caaae3894f1b854d006ac61ecc727ee/frozenlist-1.8.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:4970ece02dbc8c3a92fcc5228e36a3e933a01a999f7094ff7c23fbd2beeaa67c", size = 49749, upload-time = "2025-10-06T05:37:10.569Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/b2/fabede9fafd976b991e9f1b9c8c873ed86f202889b864756f240ce6dd855/frozenlist-1.8.0-cp314-cp314-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:cba69cb73723c3f329622e34bdbf5ce1f80c21c290ff04256cff1cd3c2036ed2", size = 231298, upload-time = "2025-10-06T05:37:11.993Z" },
+    { url = "https://files.pythonhosted.org/packages/3a/3b/d9b1e0b0eed36e70477ffb8360c49c85c8ca8ef9700a4e6711f39a6e8b45/frozenlist-1.8.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:778a11b15673f6f1df23d9586f83c4846c471a8af693a22e066508b77d201ec8", size = 232015, upload-time = "2025-10-06T05:37:13.194Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/94/be719d2766c1138148564a3960fc2c06eb688da592bdc25adcf856101be7/frozenlist-1.8.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:0325024fe97f94c41c08872db482cf8ac4800d80e79222c6b0b7b162d5b13686", size = 225038, upload-time = "2025-10-06T05:37:14.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/09/6712b6c5465f083f52f50cf74167b92d4ea2f50e46a9eea0523d658454ae/frozenlist-1.8.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:97260ff46b207a82a7567b581ab4190bd4dfa09f4db8a8b49d1a958f6aa4940e", size = 240130, upload-time = "2025-10-06T05:37:15.781Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/d4/cd065cdcf21550b54f3ce6a22e143ac9e4836ca42a0de1022da8498eac89/frozenlist-1.8.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:54b2077180eb7f83dd52c40b2750d0a9f175e06a42e3213ce047219de902717a", size = 242845, upload-time = "2025-10-06T05:37:17.037Z" },
+    { url = "https://files.pythonhosted.org/packages/62/c3/f57a5c8c70cd1ead3d5d5f776f89d33110b1addae0ab010ad774d9a44fb9/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:2f05983daecab868a31e1da44462873306d3cbfd76d1f0b5b69c473d21dbb128", size = 229131, upload-time = "2025-10-06T05:37:18.221Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/52/232476fe9cb64f0742f3fde2b7d26c1dac18b6d62071c74d4ded55e0ef94/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:33f48f51a446114bc5d251fb2954ab0164d5be02ad3382abcbfe07e2531d650f", size = 240542, upload-time = "2025-10-06T05:37:19.771Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/85/07bf3f5d0fb5414aee5f47d33c6f5c77bfe49aac680bfece33d4fdf6a246/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:154e55ec0655291b5dd1b8731c637ecdb50975a2ae70c606d100750a540082f7", size = 237308, upload-time = "2025-10-06T05:37:20.969Z" },
+    { url = "https://files.pythonhosted.org/packages/11/99/ae3a33d5befd41ac0ca2cc7fd3aa707c9c324de2e89db0e0f45db9a64c26/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:4314debad13beb564b708b4a496020e5306c7333fa9a3ab90374169a20ffab30", size = 238210, upload-time = "2025-10-06T05:37:22.252Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/60/b1d2da22f4970e7a155f0adde9b1435712ece01b3cd45ba63702aea33938/frozenlist-1.8.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:073f8bf8becba60aa931eb3bc420b217bb7d5b8f4750e6f8b3be7f3da85d38b7", size = 231972, upload-time = "2025-10-06T05:37:23.5Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/ab/945b2f32de889993b9c9133216c068b7fcf257d8595a0ac420ac8677cab0/frozenlist-1.8.0-cp314-cp314-win32.whl", hash = "sha256:bac9c42ba2ac65ddc115d930c78d24ab8d4f465fd3fc473cdedfccadb9429806", size = 40536, upload-time = "2025-10-06T05:37:25.581Z" },
+    { url = "https://files.pythonhosted.org/packages/59/ad/9caa9b9c836d9ad6f067157a531ac48b7d36499f5036d4141ce78c230b1b/frozenlist-1.8.0-cp314-cp314-win_amd64.whl", hash = "sha256:3e0761f4d1a44f1d1a47996511752cf3dcec5bbdd9cc2b4fe595caf97754b7a0", size = 44330, upload-time = "2025-10-06T05:37:26.928Z" },
+    { url = "https://files.pythonhosted.org/packages/82/13/e6950121764f2676f43534c555249f57030150260aee9dcf7d64efda11dd/frozenlist-1.8.0-cp314-cp314-win_arm64.whl", hash = "sha256:d1eaff1d00c7751b7c6662e9c5ba6eb2c17a2306ba5e2a37f24ddf3cc953402b", size = 40627, upload-time = "2025-10-06T05:37:28.075Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/c7/43200656ecc4e02d3f8bc248df68256cd9572b3f0017f0a0c4e93440ae23/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:d3bb933317c52d7ea5004a1c442eef86f426886fba134ef8cf4226ea6ee1821d", size = 89238, upload-time = "2025-10-06T05:37:29.373Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/29/55c5f0689b9c0fb765055629f472c0de484dcaf0acee2f7707266ae3583c/frozenlist-1.8.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:8009897cdef112072f93a0efdce29cd819e717fd2f649ee3016efd3cd885a7ed", size = 50738, upload-time = "2025-10-06T05:37:30.792Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/7d/b7282a445956506fa11da8c2db7d276adcbf2b17d8bb8407a47685263f90/frozenlist-1.8.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2c5dcbbc55383e5883246d11fd179782a9d07a986c40f49abe89ddf865913930", size = 51739, upload-time = "2025-10-06T05:37:32.127Z" },
+    { url = "https://files.pythonhosted.org/packages/62/1c/3d8622e60d0b767a5510d1d3cf21065b9db874696a51ea6d7a43180a259c/frozenlist-1.8.0-cp314-cp314t-manylinux1_x86_64.manylinux_2_28_x86_64.manylinux_2_5_x86_64.whl", hash = "sha256:39ecbc32f1390387d2aa4f5a995e465e9e2f79ba3adcac92d68e3e0afae6657c", size = 284186, upload-time = "2025-10-06T05:37:33.21Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/14/aa36d5f85a89679a85a1d44cd7a6657e0b1c75f61e7cad987b203d2daca8/frozenlist-1.8.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:92db2bf818d5cc8d9c1f1fc56b897662e24ea5adb36ad1f1d82875bd64e03c24", size = 292196, upload-time = "2025-10-06T05:37:36.107Z" },
+    { url = "https://files.pythonhosted.org/packages/05/23/6bde59eb55abd407d34f77d39a5126fb7b4f109a3f611d3929f14b700c66/frozenlist-1.8.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2dc43a022e555de94c3b68a4ef0b11c4f747d12c024a520c7101709a2144fb37", size = 273830, upload-time = "2025-10-06T05:37:37.663Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/3f/22cff331bfad7a8afa616289000ba793347fcd7bc275f3b28ecea2a27909/frozenlist-1.8.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:cb89a7f2de3602cfed448095bab3f178399646ab7c61454315089787df07733a", size = 294289, upload-time = "2025-10-06T05:37:39.261Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/89/5b057c799de4838b6c69aa82b79705f2027615e01be996d2486a69ca99c4/frozenlist-1.8.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:33139dc858c580ea50e7e60a1b0ea003efa1fd42e6ec7fdbad78fff65fad2fd2", size = 300318, upload-time = "2025-10-06T05:37:43.213Z" },
+    { url = "https://files.pythonhosted.org/packages/30/de/2c22ab3eb2a8af6d69dc799e48455813bab3690c760de58e1bf43b36da3e/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:168c0969a329b416119507ba30b9ea13688fafffac1b7822802537569a1cb0ef", size = 282814, upload-time = "2025-10-06T05:37:45.337Z" },
+    { url = "https://files.pythonhosted.org/packages/59/f7/970141a6a8dbd7f556d94977858cfb36fa9b66e0892c6dd780d2219d8cd8/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:28bd570e8e189d7f7b001966435f9dac6718324b5be2990ac496cf1ea9ddb7fe", size = 291762, upload-time = "2025-10-06T05:37:46.657Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/15/ca1adae83a719f82df9116d66f5bb28bb95557b3951903d39135620ef157/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:b2a095d45c5d46e5e79ba1e5b9cb787f541a8dee0433836cea4b96a2c439dcd8", size = 289470, upload-time = "2025-10-06T05:37:47.946Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/83/dca6dc53bf657d371fbc88ddeb21b79891e747189c5de990b9dfff2ccba1/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:eab8145831a0d56ec9c4139b6c3e594c7a83c2c8be25d5bcf2d86136a532287a", size = 289042, upload-time = "2025-10-06T05:37:49.499Z" },
+    { url = "https://files.pythonhosted.org/packages/96/52/abddd34ca99be142f354398700536c5bd315880ed0a213812bc491cff5e4/frozenlist-1.8.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:974b28cf63cc99dfb2188d8d222bc6843656188164848c4f679e63dae4b0708e", size = 283148, upload-time = "2025-10-06T05:37:50.745Z" },
+    { url = "https://files.pythonhosted.org/packages/af/d3/76bd4ed4317e7119c2b7f57c3f6934aba26d277acc6309f873341640e21f/frozenlist-1.8.0-cp314-cp314t-win32.whl", hash = "sha256:342c97bf697ac5480c0a7ec73cd700ecfa5a8a40ac923bd035484616efecc2df", size = 44676, upload-time = "2025-10-06T05:37:52.222Z" },
+    { url = "https://files.pythonhosted.org/packages/89/76/c615883b7b521ead2944bb3480398cbb07e12b7b4e4d073d3752eb721558/frozenlist-1.8.0-cp314-cp314t-win_amd64.whl", hash = "sha256:06be8f67f39c8b1dc671f5d83aaefd3358ae5cdcf8314552c57e7ed3e6475bdd", size = 49451, upload-time = "2025-10-06T05:37:53.425Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/a3/5982da14e113d07b325230f95060e2169f5311b1017ea8af2a29b374c289/frozenlist-1.8.0-cp314-cp314t-win_arm64.whl", hash = "sha256:102e6314ca4da683dca92e3b1355490fed5f313b768500084fbe6371fddfdb79", size = 42507, upload-time = "2025-10-06T05:37:54.513Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/e35b4a917281c0b8419d4207f4334c8e8c5dbf4f3f5f9ada73958d937dcc/frozenlist-1.8.0-py3-none-any.whl", hash = "sha256:0c18a16eab41e82c295618a77502e17b195883241c563b00f0aa5106fc4eaa0d", size = 13409, upload-time = "2025-10-06T05:38:16.721Z" },
+]
+
+[[package]]
+name = "h11"
+version = "0.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/01/ee/02a2c011bdab74c6fb3c75474d40b3052059d95df7e73351460c8588d963/h11-0.16.0.tar.gz", hash = "sha256:4e35b956cf45792e4caa5885e69fba00bdbc6ffafbfa020300e549b208ee5ff1", size = 101250, upload-time = "2025-04-24T03:35:25.427Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl", hash = "sha256:63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86", size = 37515, upload-time = "2025-04-24T03:35:24.344Z" },
+]
+
+[[package]]
+name = "httpcore"
+version = "1.0.9"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "certifi" },
+    { name = "h11" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/06/94/82699a10bca87a5556c9c59b5963f2d039dbd239f25bc2a63907a05a14cb/httpcore-1.0.9.tar.gz", hash = "sha256:6e34463af53fd2ab5d807f399a9b45ea31c3dfa2276f15a2c3f00afff6e176e8", size = 85484, upload-time = "2025-04-24T22:06:22.219Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl", hash = "sha256:2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55", size = 78784, upload-time = "2025-04-24T22:06:20.566Z" },
+]
+
+[[package]]
+name = "httpx"
+version = "0.28.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "anyio" },
+    { name = "certifi" },
+    { name = "httpcore" },
+    { name = "idna" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/b1/df/48c586a5fe32a0f01324ee087459e112ebb7224f646c0b5023f5e79e9956/httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc", size = 141406, upload-time = "2024-12-06T15:37:23.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad", size = 73517, upload-time = "2024-12-06T15:37:21.509Z" },
+]
+
+[[package]]
+name = "idna"
+version = "3.11"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/6f/6d/0703ccc57f3a7233505399edb88de3cbd678da106337b9fcde432b65ed60/idna-3.11.tar.gz", hash = "sha256:795dafcc9c04ed0c1fb032c2aa73654d8e8c5023a7df64a53f39190ada629902", size = 194582, upload-time = "2025-10-12T14:55:20.501Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0e/61/66938bbb5fc52dbdf84594873d5b51fb1f7c7794e9c0f5bd885f30bc507b/idna-3.11-py3-none-any.whl", hash = "sha256:771a87f49d9defaf64091e6e6fe9c18d4833f140bd19464795bc32d966ca37ea", size = 71008, upload-time = "2025-10-12T14:55:18.883Z" },
+]
+
+[[package]]
+name = "isort"
+version = "7.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/63/53/4f3c058e3bace40282876f9b553343376ee687f3c35a525dc79dbd450f88/isort-7.0.0.tar.gz", hash = "sha256:5513527951aadb3ac4292a41a16cbc50dd1642432f5e8c20057d414bdafb4187", size = 805049, upload-time = "2025-10-11T13:30:59.107Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7f/ed/e3705d6d02b4f7aea715a353c8ce193efd0b5db13e204df895d38734c244/isort-7.0.0-py3-none-any.whl", hash = "sha256:1bcabac8bc3c36c7fb7b98a76c8abb18e0f841a3ba81decac7691008592499c1", size = 94672, upload-time = "2025-10-11T13:30:57.665Z" },
+]
+
+[[package]]
+name = "loguru"
+version = "0.7.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "win32-setctime", marker = "sys_platform == 'win32'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/3a/05/a1dae3dffd1116099471c643b8924f5aa6524411dc6c63fdae648c4f1aca/loguru-0.7.3.tar.gz", hash = "sha256:19480589e77d47b8d85b2c827ad95d49bf31b0dcde16593892eb51dd18706eb6", size = 63559, upload-time = "2024-12-06T11:20:56.608Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/0c/29/0348de65b8cc732daa3e33e67806420b2ae89bdce2b04af740289c5c6c8c/loguru-0.7.3-py3-none-any.whl", hash = "sha256:31a33c10c8e1e10422bfd431aeb5d351c7cf7fa671e3c4df004162264b28220c", size = 61595, upload-time = "2024-12-06T11:20:54.538Z" },
+]
+
+[[package]]
+name = "multidict"
+version = "6.7.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/80/1e/5492c365f222f907de1039b91f922b93fa4f764c713ee858d235495d8f50/multidict-6.7.0.tar.gz", hash = "sha256:c6e99d9a65ca282e578dfea819cfa9c0a62b2499d8677392e09feaf305e9e6f5", size = 101834, upload-time = "2025-10-06T14:52:30.657Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c2/9e/9f61ac18d9c8b475889f32ccfa91c9f59363480613fc807b6e3023d6f60b/multidict-6.7.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:8a3862568a36d26e650a19bb5cbbba14b71789032aebc0423f8cc5f150730184", size = 76877, upload-time = "2025-10-06T14:49:20.884Z" },
+    { url = "https://files.pythonhosted.org/packages/38/6f/614f09a04e6184f8824268fce4bc925e9849edfa654ddd59f0b64508c595/multidict-6.7.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:960c60b5849b9b4f9dcc9bea6e3626143c252c74113df2c1540aebce70209b45", size = 45467, upload-time = "2025-10-06T14:49:22.054Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/93/c4f67a436dd026f2e780c433277fff72be79152894d9fc36f44569cab1a6/multidict-6.7.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2049be98fb57a31b4ccf870bf377af2504d4ae35646a19037ec271e4c07998aa", size = 43834, upload-time = "2025-10-06T14:49:23.566Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f5/013798161ca665e4a422afbc5e2d9e4070142a9ff8905e482139cd09e4d0/multidict-6.7.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:0934f3843a1860dd465d38895c17fce1f1cb37295149ab05cd1b9a03afacb2a7", size = 250545, upload-time = "2025-10-06T14:49:24.882Z" },
+    { url = "https://files.pythonhosted.org/packages/71/2f/91dbac13e0ba94669ea5119ba267c9a832f0cb65419aca75549fcf09a3dc/multidict-6.7.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b3e34f3a1b8131ba06f1a73adab24f30934d148afcd5f5de9a73565a4404384e", size = 258305, upload-time = "2025-10-06T14:49:26.778Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/b0/754038b26f6e04488b48ac621f779c341338d78503fb45403755af2df477/multidict-6.7.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:efbb54e98446892590dc2458c19c10344ee9a883a79b5cec4bc34d6656e8d546", size = 242363, upload-time = "2025-10-06T14:49:28.562Z" },
+    { url = "https://files.pythonhosted.org/packages/87/15/9da40b9336a7c9fa606c4cf2ed80a649dffeb42b905d4f63a1d7eb17d746/multidict-6.7.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a35c5fc61d4f51eb045061e7967cfe3123d622cd500e8868e7c0c592a09fedc4", size = 268375, upload-time = "2025-10-06T14:49:29.96Z" },
+    { url = "https://files.pythonhosted.org/packages/82/72/c53fcade0cc94dfaad583105fd92b3a783af2091eddcb41a6d5a52474000/multidict-6.7.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:29fe6740ebccba4175af1b9b87bf553e9c15cd5868ee967e010efcf94e4fd0f1", size = 269346, upload-time = "2025-10-06T14:49:31.404Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/e2/9baffdae21a76f77ef8447f1a05a96ec4bc0a24dae08767abc0a2fe680b8/multidict-6.7.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:123e2a72e20537add2f33a79e605f6191fba2afda4cbb876e35c1a7074298a7d", size = 256107, upload-time = "2025-10-06T14:49:32.974Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/06/3f06f611087dc60d65ef775f1fb5aca7c6d61c6db4990e7cda0cef9b1651/multidict-6.7.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b284e319754366c1aee2267a2036248b24eeb17ecd5dc16022095e747f2f4304", size = 253592, upload-time = "2025-10-06T14:49:34.52Z" },
+    { url = "https://files.pythonhosted.org/packages/20/24/54e804ec7945b6023b340c412ce9c3f81e91b3bf5fa5ce65558740141bee/multidict-6.7.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:803d685de7be4303b5a657b76e2f6d1240e7e0a8aa2968ad5811fa2285553a12", size = 251024, upload-time = "2025-10-06T14:49:35.956Z" },
+    { url = "https://files.pythonhosted.org/packages/14/48/011cba467ea0b17ceb938315d219391d3e421dfd35928e5dbdc3f4ae76ef/multidict-6.7.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:c04a328260dfd5db8c39538f999f02779012268f54614902d0afc775d44e0a62", size = 251484, upload-time = "2025-10-06T14:49:37.631Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/2f/919258b43bb35b99fa127435cfb2d91798eb3a943396631ef43e3720dcf4/multidict-6.7.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:8a19cdb57cd3df4cd865849d93ee14920fb97224300c88501f16ecfa2604b4e0", size = 263579, upload-time = "2025-10-06T14:49:39.502Z" },
+    { url = "https://files.pythonhosted.org/packages/31/22/a0e884d86b5242b5a74cf08e876bdf299e413016b66e55511f7a804a366e/multidict-6.7.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b2fd74c52accced7e75de26023b7dccee62511a600e62311b918ec5c168fc2a", size = 259654, upload-time = "2025-10-06T14:49:41.32Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/e5/17e10e1b5c5f5a40f2fcbb45953c9b215f8a4098003915e46a93f5fcaa8f/multidict-6.7.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3e8bfdd0e487acf992407a140d2589fe598238eaeffa3da8448d63a63cd363f8", size = 251511, upload-time = "2025-10-06T14:49:46.021Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/9a/201bb1e17e7af53139597069c375e7b0dcbd47594604f65c2d5359508566/multidict-6.7.0-cp312-cp312-win32.whl", hash = "sha256:dd32a49400a2c3d52088e120ee00c1e3576cbff7e10b98467962c74fdb762ed4", size = 41895, upload-time = "2025-10-06T14:49:48.718Z" },
+    { url = "https://files.pythonhosted.org/packages/46/e2/348cd32faad84eaf1d20cce80e2bb0ef8d312c55bca1f7fa9865e7770aaf/multidict-6.7.0-cp312-cp312-win_amd64.whl", hash = "sha256:92abb658ef2d7ef22ac9f8bb88e8b6c3e571671534e029359b6d9e845923eb1b", size = 46073, upload-time = "2025-10-06T14:49:50.28Z" },
+    { url = "https://files.pythonhosted.org/packages/25/ec/aad2613c1910dce907480e0c3aa306905830f25df2e54ccc9dea450cb5aa/multidict-6.7.0-cp312-cp312-win_arm64.whl", hash = "sha256:490dab541a6a642ce1a9d61a4781656b346a55c13038f0b1244653828e3a83ec", size = 43226, upload-time = "2025-10-06T14:49:52.304Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/86/33272a544eeb36d66e4d9a920602d1a2f57d4ebea4ef3cdfe5a912574c95/multidict-6.7.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bee7c0588aa0076ce77c0ea5d19a68d76ad81fcd9fe8501003b9a24f9d4000f6", size = 76135, upload-time = "2025-10-06T14:49:54.26Z" },
+    { url = "https://files.pythonhosted.org/packages/91/1c/eb97db117a1ebe46d457a3d235a7b9d2e6dcab174f42d1b67663dd9e5371/multidict-6.7.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:7ef6b61cad77091056ce0e7ce69814ef72afacb150b7ac6a3e9470def2198159", size = 45117, upload-time = "2025-10-06T14:49:55.82Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/d8/6c3442322e41fb1dd4de8bd67bfd11cd72352ac131f6368315617de752f1/multidict-6.7.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9c0359b1ec12b1d6849c59f9d319610b7f20ef990a6d454ab151aa0e3b9f78ca", size = 43472, upload-time = "2025-10-06T14:49:57.048Z" },
+    { url = "https://files.pythonhosted.org/packages/75/3f/e2639e80325af0b6c6febdf8e57cc07043ff15f57fa1ef808f4ccb5ac4cd/multidict-6.7.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:cd240939f71c64bd658f186330603aac1a9a81bf6273f523fca63673cb7378a8", size = 249342, upload-time = "2025-10-06T14:49:58.368Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/cc/84e0585f805cbeaa9cbdaa95f9a3d6aed745b9d25700623ac89a6ecff400/multidict-6.7.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a60a4d75718a5efa473ebd5ab685786ba0c67b8381f781d1be14da49f1a2dc60", size = 257082, upload-time = "2025-10-06T14:49:59.89Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/9c/ac851c107c92289acbbf5cfb485694084690c1b17e555f44952c26ddc5bd/multidict-6.7.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:53a42d364f323275126aff81fb67c5ca1b7a04fda0546245730a55c8c5f24bc4", size = 240704, upload-time = "2025-10-06T14:50:01.485Z" },
+    { url = "https://files.pythonhosted.org/packages/50/cc/5f93e99427248c09da95b62d64b25748a5f5c98c7c2ab09825a1d6af0e15/multidict-6.7.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3b29b980d0ddbecb736735ee5bef69bb2ddca56eff603c86f3f29a1128299b4f", size = 266355, upload-time = "2025-10-06T14:50:02.955Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/0c/2ec1d883ceb79c6f7f6d7ad90c919c898f5d1c6ea96d322751420211e072/multidict-6.7.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f8a93b1c0ed2d04b97a5e9336fd2d33371b9a6e29ab7dd6503d63407c20ffbaf", size = 267259, upload-time = "2025-10-06T14:50:04.446Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/2d/f0b184fa88d6630aa267680bdb8623fb69cb0d024b8c6f0d23f9a0f406d3/multidict-6.7.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9ff96e8815eecacc6645da76c413eb3b3d34cfca256c70b16b286a687d013c32", size = 254903, upload-time = "2025-10-06T14:50:05.98Z" },
+    { url = "https://files.pythonhosted.org/packages/06/c9/11ea263ad0df7dfabcad404feb3c0dd40b131bc7f232d5537f2fb1356951/multidict-6.7.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:7516c579652f6a6be0e266aec0acd0db80829ca305c3d771ed898538804c2036", size = 252365, upload-time = "2025-10-06T14:50:07.511Z" },
+    { url = "https://files.pythonhosted.org/packages/41/88/d714b86ee2c17d6e09850c70c9d310abac3d808ab49dfa16b43aba9d53fd/multidict-6.7.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:040f393368e63fb0f3330e70c26bfd336656bed925e5cbe17c9da839a6ab13ec", size = 250062, upload-time = "2025-10-06T14:50:09.074Z" },
+    { url = "https://files.pythonhosted.org/packages/15/fe/ad407bb9e818c2b31383f6131ca19ea7e35ce93cf1310fce69f12e89de75/multidict-6.7.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b3bc26a951007b1057a1c543af845f1c7e3e71cc240ed1ace7bf4484aa99196e", size = 249683, upload-time = "2025-10-06T14:50:10.714Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/a4/a89abdb0229e533fb925e7c6e5c40201c2873efebc9abaf14046a4536ee6/multidict-6.7.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:7b022717c748dd1992a83e219587aabe45980d88969f01b316e78683e6285f64", size = 261254, upload-time = "2025-10-06T14:50:12.28Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/aa/0e2b27bd88b40a4fb8dc53dd74eecac70edaa4c1dd0707eb2164da3675b3/multidict-6.7.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:9600082733859f00d79dee64effc7aef1beb26adb297416a4ad2116fd61374bd", size = 257967, upload-time = "2025-10-06T14:50:14.16Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/8e/0c67b7120d5d5f6d874ed85a085f9dc770a7f9d8813e80f44a9fec820bb7/multidict-6.7.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:94218fcec4d72bc61df51c198d098ce2b378e0ccbac41ddbed5ef44092913288", size = 250085, upload-time = "2025-10-06T14:50:15.639Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/55/b73e1d624ea4b8fd4dd07a3bb70f6e4c7c6c5d9d640a41c6ffe5cdbd2a55/multidict-6.7.0-cp313-cp313-win32.whl", hash = "sha256:a37bd74c3fa9d00be2d7b8eca074dc56bd8077ddd2917a839bd989612671ed17", size = 41713, upload-time = "2025-10-06T14:50:17.066Z" },
+    { url = "https://files.pythonhosted.org/packages/32/31/75c59e7d3b4205075b4c183fa4ca398a2daf2303ddf616b04ae6ef55cffe/multidict-6.7.0-cp313-cp313-win_amd64.whl", hash = "sha256:30d193c6cc6d559db42b6bcec8a5d395d34d60c9877a0b71ecd7c204fcf15390", size = 45915, upload-time = "2025-10-06T14:50:18.264Z" },
+    { url = "https://files.pythonhosted.org/packages/31/2a/8987831e811f1184c22bc2e45844934385363ee61c0a2dcfa8f71b87e608/multidict-6.7.0-cp313-cp313-win_arm64.whl", hash = "sha256:ea3334cabe4d41b7ccd01e4d349828678794edbc2d3ae97fc162a3312095092e", size = 43077, upload-time = "2025-10-06T14:50:19.853Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/68/7b3a5170a382a340147337b300b9eb25a9ddb573bcdfff19c0fa3f31ffba/multidict-6.7.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:ad9ce259f50abd98a1ca0aa6e490b58c316a0fce0617f609723e40804add2c00", size = 83114, upload-time = "2025-10-06T14:50:21.223Z" },
+    { url = "https://files.pythonhosted.org/packages/55/5c/3fa2d07c84df4e302060f555bbf539310980362236ad49f50eeb0a1c1eb9/multidict-6.7.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:07f5594ac6d084cbb5de2df218d78baf55ef150b91f0ff8a21cc7a2e3a5a58eb", size = 48442, upload-time = "2025-10-06T14:50:22.871Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/56/67212d33239797f9bd91962bb899d72bb0f4c35a8652dcdb8ed049bef878/multidict-6.7.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0591b48acf279821a579282444814a2d8d0af624ae0bc600aa4d1b920b6e924b", size = 46885, upload-time = "2025-10-06T14:50:24.258Z" },
+    { url = "https://files.pythonhosted.org/packages/46/d1/908f896224290350721597a61a69cd19b89ad8ee0ae1f38b3f5cd12ea2ac/multidict-6.7.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:749a72584761531d2b9467cfbdfd29487ee21124c304c4b6cb760d8777b27f9c", size = 242588, upload-time = "2025-10-06T14:50:25.716Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/67/8604288bbd68680eee0ab568fdcb56171d8b23a01bcd5cb0c8fedf6e5d99/multidict-6.7.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6b4c3d199f953acd5b446bf7c0de1fe25d94e09e79086f8dc2f48a11a129cdf1", size = 249966, upload-time = "2025-10-06T14:50:28.192Z" },
+    { url = "https://files.pythonhosted.org/packages/20/33/9228d76339f1ba51e3efef7da3ebd91964d3006217aae13211653193c3ff/multidict-6.7.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:9fb0211dfc3b51efea2f349ec92c114d7754dd62c01f81c3e32b765b70c45c9b", size = 228618, upload-time = "2025-10-06T14:50:29.82Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/2d/25d9b566d10cab1c42b3b9e5b11ef79c9111eaf4463b8c257a3bd89e0ead/multidict-6.7.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:a027ec240fe73a8d6281872690b988eed307cd7d91b23998ff35ff577ca688b5", size = 257539, upload-time = "2025-10-06T14:50:31.731Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/b1/8d1a965e6637fc33de3c0d8f414485c2b7e4af00f42cab3d84e7b955c222/multidict-6.7.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:d1d964afecdf3a8288789df2f5751dc0a8261138c3768d9af117ed384e538fad", size = 256345, upload-time = "2025-10-06T14:50:33.26Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/06b5a8adbdeedada6f4fb8d8f193d44a347223b11939b42953eeb6530b6b/multidict-6.7.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:caf53b15b1b7df9fbd0709aa01409000a2b4dd03a5f6f5cc548183c7c8f8b63c", size = 247934, upload-time = "2025-10-06T14:50:34.808Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/31/b2491b5fe167ca044c6eb4b8f2c9f3b8a00b24c432c365358eadac5d7625/multidict-6.7.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:654030da3197d927f05a536a66186070e98765aa5142794c9904555d3a9d8fb5", size = 245243, upload-time = "2025-10-06T14:50:36.436Z" },
+    { url = "https://files.pythonhosted.org/packages/61/1a/982913957cb90406c8c94f53001abd9eafc271cb3e70ff6371590bec478e/multidict-6.7.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:2090d3718829d1e484706a2f525e50c892237b2bf9b17a79b059cb98cddc2f10", size = 235878, upload-time = "2025-10-06T14:50:37.953Z" },
+    { url = "https://files.pythonhosted.org/packages/be/c0/21435d804c1a1cf7a2608593f4d19bca5bcbd7a81a70b253fdd1c12af9c0/multidict-6.7.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:2d2cfeec3f6f45651b3d408c4acec0ebf3daa9bc8a112a084206f5db5d05b754", size = 243452, upload-time = "2025-10-06T14:50:39.574Z" },
+    { url = "https://files.pythonhosted.org/packages/54/0a/4349d540d4a883863191be6eb9a928846d4ec0ea007d3dcd36323bb058ac/multidict-6.7.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:4ef089f985b8c194d341eb2c24ae6e7408c9a0e2e5658699c92f497437d88c3c", size = 252312, upload-time = "2025-10-06T14:50:41.612Z" },
+    { url = "https://files.pythonhosted.org/packages/26/64/d5416038dbda1488daf16b676e4dbfd9674dde10a0cc8f4fc2b502d8125d/multidict-6.7.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e93a0617cd16998784bf4414c7e40f17a35d2350e5c6f0bd900d3a8e02bd3762", size = 246935, upload-time = "2025-10-06T14:50:43.972Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/8c/8290c50d14e49f35e0bd4abc25e1bc7711149ca9588ab7d04f886cdf03d9/multidict-6.7.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:f0feece2ef8ebc42ed9e2e8c78fc4aa3cf455733b507c09ef7406364c94376c6", size = 243385, upload-time = "2025-10-06T14:50:45.648Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/a0/f83ae75e42d694b3fbad3e047670e511c138be747bc713cf1b10d5096416/multidict-6.7.0-cp313-cp313t-win32.whl", hash = "sha256:19a1d55338ec1be74ef62440ca9e04a2f001a04d0cc49a4983dc320ff0f3212d", size = 47777, upload-time = "2025-10-06T14:50:47.154Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/80/9b174a92814a3830b7357307a792300f42c9e94664b01dee8e457551fa66/multidict-6.7.0-cp313-cp313t-win_amd64.whl", hash = "sha256:3da4fb467498df97e986af166b12d01f05d2e04f978a9c1c680ea1988e0bc4b6", size = 53104, upload-time = "2025-10-06T14:50:48.851Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/28/04baeaf0428d95bb7a7bea0e691ba2f31394338ba424fb0679a9ed0f4c09/multidict-6.7.0-cp313-cp313t-win_arm64.whl", hash = "sha256:b4121773c49a0776461f4a904cdf6264c88e42218aaa8407e803ca8025872792", size = 45503, upload-time = "2025-10-06T14:50:50.16Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/b1/3da6934455dd4b261d4c72f897e3a5728eba81db59959f3a639245891baa/multidict-6.7.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3bab1e4aff7adaa34410f93b1f8e57c4b36b9af0426a76003f441ee1d3c7e842", size = 75128, upload-time = "2025-10-06T14:50:51.92Z" },
+    { url = "https://files.pythonhosted.org/packages/14/2c/f069cab5b51d175a1a2cb4ccdf7a2c2dabd58aa5bd933fa036a8d15e2404/multidict-6.7.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:b8512bac933afc3e45fb2b18da8e59b78d4f408399a960339598374d4ae3b56b", size = 44410, upload-time = "2025-10-06T14:50:53.275Z" },
+    { url = "https://files.pythonhosted.org/packages/42/e2/64bb41266427af6642b6b128e8774ed84c11b80a90702c13ac0a86bb10cc/multidict-6.7.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:79dcf9e477bc65414ebfea98ffd013cb39552b5ecd62908752e0e413d6d06e38", size = 43205, upload-time = "2025-10-06T14:50:54.911Z" },
+    { url = "https://files.pythonhosted.org/packages/02/68/6b086fef8a3f1a8541b9236c594f0c9245617c29841f2e0395d979485cde/multidict-6.7.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:31bae522710064b5cbeddaf2e9f32b1abab70ac6ac91d42572502299e9953128", size = 245084, upload-time = "2025-10-06T14:50:56.369Z" },
+    { url = "https://files.pythonhosted.org/packages/15/ee/f524093232007cd7a75c1d132df70f235cfd590a7c9eaccd7ff422ef4ae8/multidict-6.7.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a0df7ff02397bb63e2fd22af2c87dfa39e8c7f12947bc524dbdc528282c7e34", size = 252667, upload-time = "2025-10-06T14:50:57.991Z" },
+    { url = "https://files.pythonhosted.org/packages/02/a5/eeb3f43ab45878f1895118c3ef157a480db58ede3f248e29b5354139c2c9/multidict-6.7.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7a0222514e8e4c514660e182d5156a415c13ef0aabbd71682fc714e327b95e99", size = 233590, upload-time = "2025-10-06T14:50:59.589Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1e/76d02f8270b97269d7e3dbd45644b1785bda457b474315f8cf999525a193/multidict-6.7.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2397ab4daaf2698eb51a76721e98db21ce4f52339e535725de03ea962b5a3202", size = 264112, upload-time = "2025-10-06T14:51:01.183Z" },
+    { url = "https://files.pythonhosted.org/packages/76/0b/c28a70ecb58963847c2a8efe334904cd254812b10e535aefb3bcce513918/multidict-6.7.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:8891681594162635948a636c9fe0ff21746aeb3dd5463f6e25d9bea3a8a39ca1", size = 261194, upload-time = "2025-10-06T14:51:02.794Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/63/2ab26e4209773223159b83aa32721b4021ffb08102f8ac7d689c943fded1/multidict-6.7.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:18706cc31dbf402a7945916dd5cddf160251b6dab8a2c5f3d6d5a55949f676b3", size = 248510, upload-time = "2025-10-06T14:51:04.724Z" },
+    { url = "https://files.pythonhosted.org/packages/93/cd/06c1fa8282af1d1c46fd55c10a7930af652afdce43999501d4d68664170c/multidict-6.7.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f844a1bbf1d207dd311a56f383f7eda2d0e134921d45751842d8235e7778965d", size = 248395, upload-time = "2025-10-06T14:51:06.306Z" },
+    { url = "https://files.pythonhosted.org/packages/99/ac/82cb419dd6b04ccf9e7e61befc00c77614fc8134362488b553402ecd55ce/multidict-6.7.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:d4393e3581e84e5645506923816b9cc81f5609a778c7e7534054091acc64d1c6", size = 239520, upload-time = "2025-10-06T14:51:08.091Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/f3/a0f9bf09493421bd8716a362e0cd1d244f5a6550f5beffdd6b47e885b331/multidict-6.7.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fbd18dc82d7bf274b37aa48d664534330af744e03bccf696d6f4c6042e7d19e7", size = 245479, upload-time = "2025-10-06T14:51:10.365Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/01/476d38fc73a212843f43c852b0eee266b6971f0e28329c2184a8df90c376/multidict-6.7.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:b6234e14f9314731ec45c42fc4554b88133ad53a09092cc48a88e771c125dadb", size = 258903, upload-time = "2025-10-06T14:51:12.466Z" },
+    { url = "https://files.pythonhosted.org/packages/49/6d/23faeb0868adba613b817d0e69c5f15531b24d462af8012c4f6de4fa8dc3/multidict-6.7.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:08d4379f9744d8f78d98c8673c06e202ffa88296f009c71bbafe8a6bf847d01f", size = 252333, upload-time = "2025-10-06T14:51:14.48Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/cc/48d02ac22b30fa247f7dad82866e4b1015431092f4ba6ebc7e77596e0b18/multidict-6.7.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:9fe04da3f79387f450fd0061d4dd2e45a72749d31bf634aecc9e27f24fdc4b3f", size = 243411, upload-time = "2025-10-06T14:51:16.072Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/03/29a8bf5a18abf1fe34535c88adbdfa88c9fb869b5a3b120692c64abe8284/multidict-6.7.0-cp314-cp314-win32.whl", hash = "sha256:fbafe31d191dfa7c4c51f7a6149c9fb7e914dcf9ffead27dcfd9f1ae382b3885", size = 40940, upload-time = "2025-10-06T14:51:17.544Z" },
+    { url = "https://files.pythonhosted.org/packages/82/16/7ed27b680791b939de138f906d5cf2b4657b0d45ca6f5dd6236fdddafb1a/multidict-6.7.0-cp314-cp314-win_amd64.whl", hash = "sha256:2f67396ec0310764b9222a1728ced1ab638f61aadc6226f17a71dd9324f9a99c", size = 45087, upload-time = "2025-10-06T14:51:18.875Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/3c/e3e62eb35a1950292fe39315d3c89941e30a9d07d5d2df42965ab041da43/multidict-6.7.0-cp314-cp314-win_arm64.whl", hash = "sha256:ba672b26069957ee369cfa7fc180dde1fc6f176eaf1e6beaf61fbebbd3d9c000", size = 42368, upload-time = "2025-10-06T14:51:20.225Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/40/cd499bd0dbc5f1136726db3153042a735fffd0d77268e2ee20d5f33c010f/multidict-6.7.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:c1dcc7524066fa918c6a27d61444d4ee7900ec635779058571f70d042d86ed63", size = 82326, upload-time = "2025-10-06T14:51:21.588Z" },
+    { url = "https://files.pythonhosted.org/packages/13/8a/18e031eca251c8df76daf0288e6790561806e439f5ce99a170b4af30676b/multidict-6.7.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:27e0b36c2d388dc7b6ced3406671b401e84ad7eb0656b8f3a2f46ed0ce483718", size = 48065, upload-time = "2025-10-06T14:51:22.93Z" },
+    { url = "https://files.pythonhosted.org/packages/40/71/5e6701277470a87d234e433fb0a3a7deaf3bcd92566e421e7ae9776319de/multidict-6.7.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:2a7baa46a22e77f0988e3b23d4ede5513ebec1929e34ee9495be535662c0dfe2", size = 46475, upload-time = "2025-10-06T14:51:24.352Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/6a/bab00cbab6d9cfb57afe1663318f72ec28289ea03fd4e8236bb78429893a/multidict-6.7.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:7bf77f54997a9166a2f5675d1201520586439424c2511723a7312bdb4bcc034e", size = 239324, upload-time = "2025-10-06T14:51:25.822Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/5f/8de95f629fc22a7769ade8b41028e3e5a822c1f8904f618d175945a81ad3/multidict-6.7.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e011555abada53f1578d63389610ac8a5400fc70ce71156b0aa30d326f1a5064", size = 246877, upload-time = "2025-10-06T14:51:27.604Z" },
+    { url = "https://files.pythonhosted.org/packages/23/b4/38881a960458f25b89e9f4a4fdcb02ac101cfa710190db6e5528841e67de/multidict-6.7.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:28b37063541b897fd6a318007373930a75ca6d6ac7c940dbe14731ffdd8d498e", size = 225824, upload-time = "2025-10-06T14:51:29.664Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/39/6566210c83f8a261575f18e7144736059f0c460b362e96e9cf797a24b8e7/multidict-6.7.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:05047ada7a2fde2631a0ed706f1fd68b169a681dfe5e4cf0f8e4cb6618bbc2cd", size = 253558, upload-time = "2025-10-06T14:51:31.684Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a3/67f18315100f64c269f46e6c0319fa87ba68f0f64f2b8e7fd7c72b913a0b/multidict-6.7.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:716133f7d1d946a4e1b91b1756b23c088881e70ff180c24e864c26192ad7534a", size = 252339, upload-time = "2025-10-06T14:51:33.699Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2a/1cb77266afee2458d82f50da41beba02159b1d6b1f7973afc9a1cad1499b/multidict-6.7.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d1bed1b467ef657f2a0ae62844a607909ef1c6889562de5e1d505f74457d0b96", size = 244895, upload-time = "2025-10-06T14:51:36.189Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/72/09fa7dd487f119b2eb9524946ddd36e2067c08510576d43ff68469563b3b/multidict-6.7.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ca43bdfa5d37bd6aee89d85e1d0831fb86e25541be7e9d376ead1b28974f8e5e", size = 241862, upload-time = "2025-10-06T14:51:41.291Z" },
+    { url = "https://files.pythonhosted.org/packages/65/92/bc1f8bd0853d8669300f732c801974dfc3702c3eeadae2f60cef54dc69d7/multidict-6.7.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:44b546bd3eb645fd26fb949e43c02a25a2e632e2ca21a35e2e132c8105dc8599", size = 232376, upload-time = "2025-10-06T14:51:43.55Z" },
+    { url = "https://files.pythonhosted.org/packages/09/86/ac39399e5cb9d0c2ac8ef6e10a768e4d3bc933ac808d49c41f9dc23337eb/multidict-6.7.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a6ef16328011d3f468e7ebc326f24c1445f001ca1dec335b2f8e66bed3006394", size = 240272, upload-time = "2025-10-06T14:51:45.265Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b6/fed5ac6b8563ec72df6cb1ea8dac6d17f0a4a1f65045f66b6d3bf1497c02/multidict-6.7.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:5aa873cbc8e593d361ae65c68f85faadd755c3295ea2c12040ee146802f23b38", size = 248774, upload-time = "2025-10-06T14:51:46.836Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/8d/b954d8c0dc132b68f760aefd45870978deec6818897389dace00fcde32ff/multidict-6.7.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:3d7b6ccce016e29df4b7ca819659f516f0bc7a4b3efa3bb2012ba06431b044f9", size = 242731, upload-time = "2025-10-06T14:51:48.541Z" },
+    { url = "https://files.pythonhosted.org/packages/16/9d/a2dac7009125d3540c2f54e194829ea18ac53716c61b655d8ed300120b0f/multidict-6.7.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:171b73bd4ee683d307599b66793ac80981b06f069b62eea1c9e29c9241aa66b0", size = 240193, upload-time = "2025-10-06T14:51:50.355Z" },
+    { url = "https://files.pythonhosted.org/packages/39/ca/c05f144128ea232ae2178b008d5011d4e2cea86e4ee8c85c2631b1b94802/multidict-6.7.0-cp314-cp314t-win32.whl", hash = "sha256:b2d7f80c4e1fd010b07cb26820aae86b7e73b681ee4889684fb8d2d4537aab13", size = 48023, upload-time = "2025-10-06T14:51:51.883Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8f/0a60e501584145588be1af5cc829265701ba3c35a64aec8e07cbb71d39bb/multidict-6.7.0-cp314-cp314t-win_amd64.whl", hash = "sha256:09929cab6fcb68122776d575e03c6cc64ee0b8fca48d17e135474b042ce515cd", size = 53507, upload-time = "2025-10-06T14:51:53.672Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/ae/3148b988a9c6239903e786eac19c889fab607c31d6efa7fb2147e5680f23/multidict-6.7.0-cp314-cp314t-win_arm64.whl", hash = "sha256:cc41db090ed742f32bd2d2c721861725e6109681eddf835d0a82bd3a5c382827", size = 44804, upload-time = "2025-10-06T14:51:55.415Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/da/7d22601b625e241d4f23ef1ebff8acfc60da633c9e7e7922e24d10f592b3/multidict-6.7.0-py3-none-any.whl", hash = "sha256:394fc5c42a333c9ffc3e421a4c85e08580d990e08b99f6bf35b4132114c5dcb3", size = 12317, upload-time = "2025-10-06T14:52:29.272Z" },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/6e/371856a3fb9d31ca8dac321cda606860fa4548858c0cc45d9d1d4ca2628b/mypy_extensions-1.1.0.tar.gz", hash = "sha256:52e68efc3284861e772bbcd66823fde5ae21fd2fdb51c62a211403730b916558", size = 6343, upload-time = "2025-04-22T14:54:24.164Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/79/7b/2c79738432f5c924bef5071f933bcc9efd0473bac3b4aa584a6f7c1c8df8/mypy_extensions-1.1.0-py3-none-any.whl", hash = "sha256:1be4cccdb0f2482337c4743e60421de3a356cd97508abadd57d47403e94f5505", size = 4963, upload-time = "2025-04-22T14:54:22.983Z" },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
+]
+
+[[package]]
+name = "packaging"
+version = "25.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a1/d4/1fc4078c65507b51b96ca8f8c3ba19e6a61c8253c72794544580a7b6c24d/packaging-25.0.tar.gz", hash = "sha256:d443872c98d677bf60f6a1f2f8c1cb748e8fe762d2bf9d3148b5599295b0fc4f", size = 165727, upload-time = "2025-04-19T11:48:59.673Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/20/12/38679034af332785aac8774540895e234f4d07f7545804097de4b666afd8/packaging-25.0-py3-none-any.whl", hash = "sha256:29572ef2b1f17581046b3a2227d5c611fb25ec70ca1ba8554b24b0e69331a484", size = 66469, upload-time = "2025-04-19T11:48:57.875Z" },
+]
+
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/61/33/9611380c2bdb1225fdef633e2a9610622310fed35ab11dac9620972ee088/platformdirs-4.5.0.tar.gz", hash = "sha256:70ddccdd7c99fc5942e9fc25636a8b34d04c24b335100223152c2803e4063312", size = 21632, upload-time = "2025-10-08T17:44:48.791Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/73/cb/ac7874b3e5d58441674fb70742e6c374b28b0c7cb988d37d991cde47166c/platformdirs-4.5.0-py3-none-any.whl", hash = "sha256:e578a81bb873cbb89a41fcc904c7ef523cc18284b7e3b3ccf06aca1403b7ebd3", size = 18651, upload-time = "2025-10-08T17:44:47.223Z" },
+]
+
+[[package]]
+name = "propcache"
+version = "0.4.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9e/da/e9fc233cf63743258bff22b3dfa7ea5baef7b5bc324af47a0ad89b8ffc6f/propcache-0.4.1.tar.gz", hash = "sha256:f48107a8c637e80362555f37ecf49abe20370e557cc4ab374f04ec4423c97c3d", size = 46442, upload-time = "2025-10-08T19:49:02.291Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a2/0f/f17b1b2b221d5ca28b4b876e8bb046ac40466513960646bda8e1853cdfa2/propcache-0.4.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e153e9cd40cc8945138822807139367f256f89c6810c2634a4f6902b52d3b4e2", size = 80061, upload-time = "2025-10-08T19:46:46.075Z" },
+    { url = "https://files.pythonhosted.org/packages/76/47/8ccf75935f51448ba9a16a71b783eb7ef6b9ee60f5d14c7f8a8a79fbeed7/propcache-0.4.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:cd547953428f7abb73c5ad82cbb32109566204260d98e41e5dfdc682eb7f8403", size = 46037, upload-time = "2025-10-08T19:46:47.23Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/b6/5c9a0e42df4d00bfb4a3cbbe5cf9f54260300c88a0e9af1f47ca5ce17ac0/propcache-0.4.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f048da1b4f243fc44f205dfd320933a951b8d89e0afd4c7cacc762a8b9165207", size = 47324, upload-time = "2025-10-08T19:46:48.384Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/d3/6c7ee328b39a81ee877c962469f1e795f9db87f925251efeb0545e0020d0/propcache-0.4.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ec17c65562a827bba85e3872ead335f95405ea1674860d96483a02f5c698fa72", size = 225505, upload-time = "2025-10-08T19:46:50.055Z" },
+    { url = "https://files.pythonhosted.org/packages/01/5d/1c53f4563490b1d06a684742cc6076ef944bc6457df6051b7d1a877c057b/propcache-0.4.1-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:405aac25c6394ef275dee4c709be43745d36674b223ba4eb7144bf4d691b7367", size = 230242, upload-time = "2025-10-08T19:46:51.815Z" },
+    { url = "https://files.pythonhosted.org/packages/20/e1/ce4620633b0e2422207c3cb774a0ee61cac13abc6217763a7b9e2e3f4a12/propcache-0.4.1-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0013cb6f8dde4b2a2f66903b8ba740bdfe378c943c4377a200551ceb27f379e4", size = 238474, upload-time = "2025-10-08T19:46:53.208Z" },
+    { url = "https://files.pythonhosted.org/packages/46/4b/3aae6835b8e5f44ea6a68348ad90f78134047b503765087be2f9912140ea/propcache-0.4.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:15932ab57837c3368b024473a525e25d316d8353016e7cc0e5ba9eb343fbb1cf", size = 221575, upload-time = "2025-10-08T19:46:54.511Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/a5/8a5e8678bcc9d3a1a15b9a29165640d64762d424a16af543f00629c87338/propcache-0.4.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:031dce78b9dc099f4c29785d9cf5577a3faf9ebf74ecbd3c856a7b92768c3df3", size = 216736, upload-time = "2025-10-08T19:46:56.212Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/63/b7b215eddeac83ca1c6b934f89d09a625aa9ee4ba158338854c87210cc36/propcache-0.4.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:ab08df6c9a035bee56e31af99be621526bd237bea9f32def431c656b29e41778", size = 213019, upload-time = "2025-10-08T19:46:57.595Z" },
+    { url = "https://files.pythonhosted.org/packages/57/74/f580099a58c8af587cac7ba19ee7cb418506342fbbe2d4a4401661cca886/propcache-0.4.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4d7af63f9f93fe593afbf104c21b3b15868efb2c21d07d8732c0c4287e66b6a6", size = 220376, upload-time = "2025-10-08T19:46:59.067Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ee/542f1313aff7eaf19c2bb758c5d0560d2683dac001a1c96d0774af799843/propcache-0.4.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:cfc27c945f422e8b5071b6e93169679e4eb5bf73bbcbf1ba3ae3a83d2f78ebd9", size = 226988, upload-time = "2025-10-08T19:47:00.544Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/18/9c6b015dd9c6930f6ce2229e1f02fb35298b847f2087ea2b436a5bfa7287/propcache-0.4.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:35c3277624a080cc6ec6f847cbbbb5b49affa3598c4535a0a4682a697aaa5c75", size = 215615, upload-time = "2025-10-08T19:47:01.968Z" },
+    { url = "https://files.pythonhosted.org/packages/80/9e/e7b85720b98c45a45e1fca6a177024934dc9bc5f4d5dd04207f216fc33ed/propcache-0.4.1-cp312-cp312-win32.whl", hash = "sha256:671538c2262dadb5ba6395e26c1731e1d52534bfe9ae56d0b5573ce539266aa8", size = 38066, upload-time = "2025-10-08T19:47:03.503Z" },
+    { url = "https://files.pythonhosted.org/packages/54/09/d19cff2a5aaac632ec8fc03737b223597b1e347416934c1b3a7df079784c/propcache-0.4.1-cp312-cp312-win_amd64.whl", hash = "sha256:cb2d222e72399fcf5890d1d5cc1060857b9b236adff2792ff48ca2dfd46c81db", size = 41655, upload-time = "2025-10-08T19:47:04.973Z" },
+    { url = "https://files.pythonhosted.org/packages/68/ab/6b5c191bb5de08036a8c697b265d4ca76148efb10fa162f14af14fb5f076/propcache-0.4.1-cp312-cp312-win_arm64.whl", hash = "sha256:204483131fb222bdaaeeea9f9e6c6ed0cac32731f75dfc1d4a567fc1926477c1", size = 37789, upload-time = "2025-10-08T19:47:06.077Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/df/6d9c1b6ac12b003837dde8a10231a7344512186e87b36e855bef32241942/propcache-0.4.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:43eedf29202c08550aac1d14e0ee619b0430aaef78f85864c1a892294fbc28cf", size = 77750, upload-time = "2025-10-08T19:47:07.648Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/e8/677a0025e8a2acf07d3418a2e7ba529c9c33caf09d3c1f25513023c1db56/propcache-0.4.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d62cdfcfd89ccb8de04e0eda998535c406bf5e060ffd56be6c586cbcc05b3311", size = 44780, upload-time = "2025-10-08T19:47:08.851Z" },
+    { url = "https://files.pythonhosted.org/packages/89/a4/92380f7ca60f99ebae761936bc48a72a639e8a47b29050615eef757cb2a7/propcache-0.4.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:cae65ad55793da34db5f54e4029b89d3b9b9490d8abe1b4c7ab5d4b8ec7ebf74", size = 46308, upload-time = "2025-10-08T19:47:09.982Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/48/c5ac64dee5262044348d1d78a5f85dd1a57464a60d30daee946699963eb3/propcache-0.4.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:333ddb9031d2704a301ee3e506dc46b1fe5f294ec198ed6435ad5b6a085facfe", size = 208182, upload-time = "2025-10-08T19:47:11.319Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/0c/cd762dd011a9287389a6a3eb43aa30207bde253610cca06824aeabfe9653/propcache-0.4.1-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:fd0858c20f078a32cf55f7e81473d96dcf3b93fd2ccdb3d40fdf54b8573df3af", size = 211215, upload-time = "2025-10-08T19:47:13.146Z" },
+    { url = "https://files.pythonhosted.org/packages/30/3e/49861e90233ba36890ae0ca4c660e95df565b2cd15d4a68556ab5865974e/propcache-0.4.1-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:678ae89ebc632c5c204c794f8dab2837c5f159aeb59e6ed0539500400577298c", size = 218112, upload-time = "2025-10-08T19:47:14.913Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/8b/544bc867e24e1bd48f3118cecd3b05c694e160a168478fa28770f22fd094/propcache-0.4.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d472aeb4fbf9865e0c6d622d7f4d54a4e101a89715d8904282bb5f9a2f476c3f", size = 204442, upload-time = "2025-10-08T19:47:16.277Z" },
+    { url = "https://files.pythonhosted.org/packages/50/a6/4282772fd016a76d3e5c0df58380a5ea64900afd836cec2c2f662d1b9bb3/propcache-0.4.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4d3df5fa7e36b3225954fba85589da77a0fe6a53e3976de39caf04a0db4c36f1", size = 199398, upload-time = "2025-10-08T19:47:17.962Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/ec/d8a7cd406ee1ddb705db2139f8a10a8a427100347bd698e7014351c7af09/propcache-0.4.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ee17f18d2498f2673e432faaa71698032b0127ebf23ae5974eeaf806c279df24", size = 196920, upload-time = "2025-10-08T19:47:19.355Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/6c/f38ab64af3764f431e359f8baf9e0a21013e24329e8b85d2da32e8ed07ca/propcache-0.4.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:580e97762b950f993ae618e167e7be9256b8353c2dcd8b99ec100eb50f5286aa", size = 203748, upload-time = "2025-10-08T19:47:21.338Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/e3/fa846bd70f6534d647886621388f0a265254d30e3ce47e5c8e6e27dbf153/propcache-0.4.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:501d20b891688eb8e7aa903021f0b72d5a55db40ffaab27edefd1027caaafa61", size = 205877, upload-time = "2025-10-08T19:47:23.059Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/39/8163fc6f3133fea7b5f2827e8eba2029a0277ab2c5beee6c1db7b10fc23d/propcache-0.4.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:9a0bd56e5b100aef69bd8562b74b46254e7c8812918d3baa700c8a8009b0af66", size = 199437, upload-time = "2025-10-08T19:47:24.445Z" },
+    { url = "https://files.pythonhosted.org/packages/93/89/caa9089970ca49c7c01662bd0eeedfe85494e863e8043565aeb6472ce8fe/propcache-0.4.1-cp313-cp313-win32.whl", hash = "sha256:bcc9aaa5d80322bc2fb24bb7accb4a30f81e90ab8d6ba187aec0744bc302ad81", size = 37586, upload-time = "2025-10-08T19:47:25.736Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/ab/f76ec3c3627c883215b5c8080debb4394ef5a7a29be811f786415fc1e6fd/propcache-0.4.1-cp313-cp313-win_amd64.whl", hash = "sha256:381914df18634f5494334d201e98245c0596067504b9372d8cf93f4bb23e025e", size = 40790, upload-time = "2025-10-08T19:47:26.847Z" },
+    { url = "https://files.pythonhosted.org/packages/59/1b/e71ae98235f8e2ba5004d8cb19765a74877abf189bc53fc0c80d799e56c3/propcache-0.4.1-cp313-cp313-win_arm64.whl", hash = "sha256:8873eb4460fd55333ea49b7d189749ecf6e55bf85080f11b1c4530ed3034cba1", size = 37158, upload-time = "2025-10-08T19:47:27.961Z" },
+    { url = "https://files.pythonhosted.org/packages/83/ce/a31bbdfc24ee0dcbba458c8175ed26089cf109a55bbe7b7640ed2470cfe9/propcache-0.4.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:92d1935ee1f8d7442da9c0c4fa7ac20d07e94064184811b685f5c4fada64553b", size = 81451, upload-time = "2025-10-08T19:47:29.445Z" },
+    { url = "https://files.pythonhosted.org/packages/25/9c/442a45a470a68456e710d96cacd3573ef26a1d0a60067e6a7d5e655621ed/propcache-0.4.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:473c61b39e1460d386479b9b2f337da492042447c9b685f28be4f74d3529e566", size = 46374, upload-time = "2025-10-08T19:47:30.579Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/bf/b1d5e21dbc3b2e889ea4327044fb16312a736d97640fb8b6aa3f9c7b3b65/propcache-0.4.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:c0ef0aaafc66fbd87842a3fe3902fd889825646bc21149eafe47be6072725835", size = 48396, upload-time = "2025-10-08T19:47:31.79Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/04/5b4c54a103d480e978d3c8a76073502b18db0c4bc17ab91b3cb5092ad949/propcache-0.4.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f95393b4d66bfae908c3ca8d169d5f79cd65636ae15b5e7a4f6e67af675adb0e", size = 275950, upload-time = "2025-10-08T19:47:33.481Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/c1/86f846827fb969c4b78b0af79bba1d1ea2156492e1b83dea8b8a6ae27395/propcache-0.4.1-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c07fda85708bc48578467e85099645167a955ba093be0a2dcba962195676e859", size = 273856, upload-time = "2025-10-08T19:47:34.906Z" },
+    { url = "https://files.pythonhosted.org/packages/36/1d/fc272a63c8d3bbad6878c336c7a7dea15e8f2d23a544bda43205dfa83ada/propcache-0.4.1-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:af223b406d6d000830c6f65f1e6431783fc3f713ba3e6cc8c024d5ee96170a4b", size = 280420, upload-time = "2025-10-08T19:47:36.338Z" },
+    { url = "https://files.pythonhosted.org/packages/07/0c/01f2219d39f7e53d52e5173bcb09c976609ba30209912a0680adfb8c593a/propcache-0.4.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a78372c932c90ee474559c5ddfffd718238e8673c340dc21fe45c5b8b54559a0", size = 263254, upload-time = "2025-10-08T19:47:37.692Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/18/cd28081658ce597898f0c4d174d4d0f3c5b6d4dc27ffafeef835c95eb359/propcache-0.4.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:564d9f0d4d9509e1a870c920a89b2fec951b44bf5ba7d537a9e7c1ccec2c18af", size = 261205, upload-time = "2025-10-08T19:47:39.659Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/71/1f9e22eb8b8316701c2a19fa1f388c8a3185082607da8e406a803c9b954e/propcache-0.4.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:17612831fda0138059cc5546f4d12a2aacfb9e47068c06af35c400ba58ba7393", size = 247873, upload-time = "2025-10-08T19:47:41.084Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/65/3d4b61f36af2b4eddba9def857959f1016a51066b4f1ce348e0cf7881f58/propcache-0.4.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:41a89040cb10bd345b3c1a873b2bf36413d48da1def52f268a055f7398514874", size = 262739, upload-time = "2025-10-08T19:47:42.51Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/42/26746ab087faa77c1c68079b228810436ccd9a5ce9ac85e2b7307195fd06/propcache-0.4.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e35b88984e7fa64aacecea39236cee32dd9bd8c55f57ba8a75cf2399553f9bd7", size = 263514, upload-time = "2025-10-08T19:47:43.927Z" },
+    { url = "https://files.pythonhosted.org/packages/94/13/630690fe201f5502d2403dd3cfd451ed8858fe3c738ee88d095ad2ff407b/propcache-0.4.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f8b465489f927b0df505cbe26ffbeed4d6d8a2bbc61ce90eb074ff129ef0ab1", size = 257781, upload-time = "2025-10-08T19:47:45.448Z" },
+    { url = "https://files.pythonhosted.org/packages/92/f7/1d4ec5841505f423469efbfc381d64b7b467438cd5a4bbcbb063f3b73d27/propcache-0.4.1-cp313-cp313t-win32.whl", hash = "sha256:2ad890caa1d928c7c2965b48f3a3815c853180831d0e5503d35cf00c472f4717", size = 41396, upload-time = "2025-10-08T19:47:47.202Z" },
+    { url = "https://files.pythonhosted.org/packages/48/f0/615c30622316496d2cbbc29f5985f7777d3ada70f23370608c1d3e081c1f/propcache-0.4.1-cp313-cp313t-win_amd64.whl", hash = "sha256:f7ee0e597f495cf415bcbd3da3caa3bd7e816b74d0d52b8145954c5e6fd3ff37", size = 44897, upload-time = "2025-10-08T19:47:48.336Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/ca/6002e46eccbe0e33dcd4069ef32f7f1c9e243736e07adca37ae8c4830ec3/propcache-0.4.1-cp313-cp313t-win_arm64.whl", hash = "sha256:929d7cbe1f01bb7baffb33dc14eb5691c95831450a26354cd210a8155170c93a", size = 39789, upload-time = "2025-10-08T19:47:49.876Z" },
+    { url = "https://files.pythonhosted.org/packages/8e/5c/bca52d654a896f831b8256683457ceddd490ec18d9ec50e97dfd8fc726a8/propcache-0.4.1-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:3f7124c9d820ba5548d431afb4632301acf965db49e666aa21c305cbe8c6de12", size = 78152, upload-time = "2025-10-08T19:47:51.051Z" },
+    { url = "https://files.pythonhosted.org/packages/65/9b/03b04e7d82a5f54fb16113d839f5ea1ede58a61e90edf515f6577c66fa8f/propcache-0.4.1-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:c0d4b719b7da33599dfe3b22d3db1ef789210a0597bc650b7cee9c77c2be8c5c", size = 44869, upload-time = "2025-10-08T19:47:52.594Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/fa/89a8ef0468d5833a23fff277b143d0573897cf75bd56670a6d28126c7d68/propcache-0.4.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:9f302f4783709a78240ebc311b793f123328716a60911d667e0c036bc5dcbded", size = 46596, upload-time = "2025-10-08T19:47:54.073Z" },
+    { url = "https://files.pythonhosted.org/packages/86/bd/47816020d337f4a746edc42fe8d53669965138f39ee117414c7d7a340cfe/propcache-0.4.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c80ee5802e3fb9ea37938e7eecc307fb984837091d5fd262bb37238b1ae97641", size = 206981, upload-time = "2025-10-08T19:47:55.715Z" },
+    { url = "https://files.pythonhosted.org/packages/df/f6/c5fa1357cc9748510ee55f37173eb31bfde6d94e98ccd9e6f033f2fc06e1/propcache-0.4.1-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ed5a841e8bb29a55fb8159ed526b26adc5bdd7e8bd7bf793ce647cb08656cdf4", size = 211490, upload-time = "2025-10-08T19:47:57.499Z" },
+    { url = "https://files.pythonhosted.org/packages/80/1e/e5889652a7c4a3846683401a48f0f2e5083ce0ec1a8a5221d8058fbd1adf/propcache-0.4.1-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:55c72fd6ea2da4c318e74ffdf93c4fe4e926051133657459131a95c846d16d44", size = 215371, upload-time = "2025-10-08T19:47:59.317Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/f2/889ad4b2408f72fe1a4f6a19491177b30ea7bf1a0fd5f17050ca08cfc882/propcache-0.4.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8326e144341460402713f91df60ade3c999d601e7eb5ff8f6f7862d54de0610d", size = 201424, upload-time = "2025-10-08T19:48:00.67Z" },
+    { url = "https://files.pythonhosted.org/packages/27/73/033d63069b57b0812c8bd19f311faebeceb6ba31b8f32b73432d12a0b826/propcache-0.4.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:060b16ae65bc098da7f6d25bf359f1f31f688384858204fe5d652979e0015e5b", size = 197566, upload-time = "2025-10-08T19:48:02.604Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/89/ce24f3dc182630b4e07aa6d15f0ff4b14ed4b9955fae95a0b54c58d66c05/propcache-0.4.1-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:89eb3fa9524f7bec9de6e83cf3faed9d79bffa560672c118a96a171a6f55831e", size = 193130, upload-time = "2025-10-08T19:48:04.499Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/24/ef0d5fd1a811fb5c609278d0209c9f10c35f20581fcc16f818da959fc5b4/propcache-0.4.1-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:dee69d7015dc235f526fe80a9c90d65eb0039103fe565776250881731f06349f", size = 202625, upload-time = "2025-10-08T19:48:06.213Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/02/98ec20ff5546f68d673df2f7a69e8c0d076b5abd05ca882dc7ee3a83653d/propcache-0.4.1-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:5558992a00dfd54ccbc64a32726a3357ec93825a418a401f5cc67df0ac5d9e49", size = 204209, upload-time = "2025-10-08T19:48:08.432Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/87/492694f76759b15f0467a2a93ab68d32859672b646aa8a04ce4864e7932d/propcache-0.4.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:c9b822a577f560fbd9554812526831712c1436d2c046cedee4c3796d3543b144", size = 197797, upload-time = "2025-10-08T19:48:09.968Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/36/66367de3575db1d2d3f3d177432bd14ee577a39d3f5d1b3d5df8afe3b6e2/propcache-0.4.1-cp314-cp314-win32.whl", hash = "sha256:ab4c29b49d560fe48b696cdcb127dd36e0bc2472548f3bf56cc5cb3da2b2984f", size = 38140, upload-time = "2025-10-08T19:48:11.232Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/2a/a758b47de253636e1b8aef181c0b4f4f204bf0dd964914fb2af90a95b49b/propcache-0.4.1-cp314-cp314-win_amd64.whl", hash = "sha256:5a103c3eb905fcea0ab98be99c3a9a5ab2de60228aa5aceedc614c0281cf6153", size = 41257, upload-time = "2025-10-08T19:48:12.707Z" },
+    { url = "https://files.pythonhosted.org/packages/34/5e/63bd5896c3fec12edcbd6f12508d4890d23c265df28c74b175e1ef9f4f3b/propcache-0.4.1-cp314-cp314-win_arm64.whl", hash = "sha256:74c1fb26515153e482e00177a1ad654721bf9207da8a494a0c05e797ad27b992", size = 38097, upload-time = "2025-10-08T19:48:13.923Z" },
+    { url = "https://files.pythonhosted.org/packages/99/85/9ff785d787ccf9bbb3f3106f79884a130951436f58392000231b4c737c80/propcache-0.4.1-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:824e908bce90fb2743bd6b59db36eb4f45cd350a39637c9f73b1c1ea66f5b75f", size = 81455, upload-time = "2025-10-08T19:48:15.16Z" },
+    { url = "https://files.pythonhosted.org/packages/90/85/2431c10c8e7ddb1445c1f7c4b54d886e8ad20e3c6307e7218f05922cad67/propcache-0.4.1-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c2b5e7db5328427c57c8e8831abda175421b709672f6cfc3d630c3b7e2146393", size = 46372, upload-time = "2025-10-08T19:48:16.424Z" },
+    { url = "https://files.pythonhosted.org/packages/01/20/b0972d902472da9bcb683fa595099911f4d2e86e5683bcc45de60dd05dc3/propcache-0.4.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6f6ff873ed40292cd4969ef5310179afd5db59fdf055897e282485043fc80ad0", size = 48411, upload-time = "2025-10-08T19:48:17.577Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/e3/7dc89f4f21e8f99bad3d5ddb3a3389afcf9da4ac69e3deb2dcdc96e74169/propcache-0.4.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:49a2dc67c154db2c1463013594c458881a069fcf98940e61a0569016a583020a", size = 275712, upload-time = "2025-10-08T19:48:18.901Z" },
+    { url = "https://files.pythonhosted.org/packages/20/67/89800c8352489b21a8047c773067644e3897f02ecbbd610f4d46b7f08612/propcache-0.4.1-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:005f08e6a0529984491e37d8dbc3dd86f84bd78a8ceb5fa9a021f4c48d4984be", size = 273557, upload-time = "2025-10-08T19:48:20.762Z" },
+    { url = "https://files.pythonhosted.org/packages/e2/a1/b52b055c766a54ce6d9c16d9aca0cad8059acd9637cdf8aa0222f4a026ef/propcache-0.4.1-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:5c3310452e0d31390da9035c348633b43d7e7feb2e37be252be6da45abd1abcc", size = 280015, upload-time = "2025-10-08T19:48:22.592Z" },
+    { url = "https://files.pythonhosted.org/packages/48/c8/33cee30bd890672c63743049f3c9e4be087e6780906bfc3ec58528be59c1/propcache-0.4.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4c3c70630930447f9ef1caac7728c8ad1c56bc5015338b20fed0d08ea2480b3a", size = 262880, upload-time = "2025-10-08T19:48:23.947Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b1/8f08a143b204b418285c88b83d00edbd61afbc2c6415ffafc8905da7038b/propcache-0.4.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:8e57061305815dfc910a3634dcf584f08168a8836e6999983569f51a8544cd89", size = 260938, upload-time = "2025-10-08T19:48:25.656Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/12/96e4664c82ca2f31e1c8dff86afb867348979eb78d3cb8546a680287a1e9/propcache-0.4.1-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:521a463429ef54143092c11a77e04056dd00636f72e8c45b70aaa3140d639726", size = 247641, upload-time = "2025-10-08T19:48:27.207Z" },
+    { url = "https://files.pythonhosted.org/packages/18/ed/e7a9cfca28133386ba52278136d42209d3125db08d0a6395f0cba0c0285c/propcache-0.4.1-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:120c964da3fdc75e3731aa392527136d4ad35868cc556fd09bb6d09172d9a367", size = 262510, upload-time = "2025-10-08T19:48:28.65Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/76/16d8bf65e8845dd62b4e2b57444ab81f07f40caa5652b8969b87ddcf2ef6/propcache-0.4.1-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:d8f353eb14ee3441ee844ade4277d560cdd68288838673273b978e3d6d2c8f36", size = 263161, upload-time = "2025-10-08T19:48:30.133Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/70/c99e9edb5d91d5ad8a49fa3c1e8285ba64f1476782fed10ab251ff413ba1/propcache-0.4.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:ab2943be7c652f09638800905ee1bab2c544e537edb57d527997a24c13dc1455", size = 257393, upload-time = "2025-10-08T19:48:31.567Z" },
+    { url = "https://files.pythonhosted.org/packages/08/02/87b25304249a35c0915d236575bc3574a323f60b47939a2262b77632a3ee/propcache-0.4.1-cp314-cp314t-win32.whl", hash = "sha256:05674a162469f31358c30bcaa8883cb7829fa3110bf9c0991fe27d7896c42d85", size = 42546, upload-time = "2025-10-08T19:48:32.872Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/ef/3c6ecf8b317aa982f309835e8f96987466123c6e596646d4e6a1dfcd080f/propcache-0.4.1-cp314-cp314t-win_amd64.whl", hash = "sha256:990f6b3e2a27d683cb7602ed6c86f15ee6b43b1194736f9baaeb93d0016633b1", size = 46259, upload-time = "2025-10-08T19:48:34.226Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/2d/346e946d4951f37eca1e4f55be0f0174c52cd70720f84029b02f296f4a38/propcache-0.4.1-cp314-cp314t-win_arm64.whl", hash = "sha256:ecef2343af4cc68e05131e45024ba34f6095821988a9d0a02aa7c73fcc448aa9", size = 40428, upload-time = "2025-10-08T19:48:35.441Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/5a/bc7b4a4ef808fa59a816c17b20c4bef6884daebbdf627ff2a161da67da19/propcache-0.4.1-py3-none-any.whl", hash = "sha256:af2a6052aeb6cf17d3e46ee169099044fd8224cbaf75c76a2ef596e8163e2237", size = 13305, upload-time = "2025-10-08T19:49:00.792Z" },
+]
+
+[[package]]
+name = "pydantic"
+version = "2.12.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "annotated-types" },
+    { name = "pydantic-core" },
+    { name = "typing-extensions" },
+    { name = "typing-inspection" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/1e/4f0a3233767010308f2fd6bd0814597e3f63f1dc98304a9112b8759df4ff/pydantic-2.12.3.tar.gz", hash = "sha256:1da1c82b0fc140bb0103bc1441ffe062154c8d38491189751ee00fd8ca65ce74", size = 819383, upload-time = "2025-10-17T15:04:21.222Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a1/6b/83661fa77dcefa195ad5f8cd9af3d1a7450fd57cc883ad04d65446ac2029/pydantic-2.12.3-py3-none-any.whl", hash = "sha256:6986454a854bc3bc6e5443e1369e06a3a456af9d339eda45510f517d9ea5c6bf", size = 462431, upload-time = "2025-10-17T15:04:19.346Z" },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.41.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/df/18/d0944e8eaaa3efd0a91b0f1fc537d3be55ad35091b6a87638211ba691964/pydantic_core-2.41.4.tar.gz", hash = "sha256:70e47929a9d4a1905a67e4b687d5946026390568a8e952b92824118063cee4d5", size = 457557, upload-time = "2025-10-14T10:23:47.909Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/81/d3b3e95929c4369d30b2a66a91db63c8ed0a98381ae55a45da2cd1cc1288/pydantic_core-2.41.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ab06d77e053d660a6faaf04894446df7b0a7e7aba70c2797465a0a1af00fc887", size = 2099043, upload-time = "2025-10-14T10:20:28.561Z" },
+    { url = "https://files.pythonhosted.org/packages/58/da/46fdac49e6717e3a94fc9201403e08d9d61aa7a770fab6190b8740749047/pydantic_core-2.41.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c53ff33e603a9c1179a9364b0a24694f183717b2e0da2b5ad43c316c956901b2", size = 1910699, upload-time = "2025-10-14T10:20:30.217Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/63/4d948f1b9dd8e991a5a98b77dd66c74641f5f2e5225fee37994b2e07d391/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:304c54176af2c143bd181d82e77c15c41cbacea8872a2225dd37e6544dce9999", size = 1952121, upload-time = "2025-10-14T10:20:32.246Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/a7/e5fc60a6f781fc634ecaa9ecc3c20171d238794cef69ae0af79ac11b89d7/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:025ba34a4cf4fb32f917d5d188ab5e702223d3ba603be4d8aca2f82bede432a4", size = 2041590, upload-time = "2025-10-14T10:20:34.332Z" },
+    { url = "https://files.pythonhosted.org/packages/70/69/dce747b1d21d59e85af433428978a1893c6f8a7068fa2bb4a927fba7a5ff/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b9f5f30c402ed58f90c70e12eff65547d3ab74685ffe8283c719e6bead8ef53f", size = 2219869, upload-time = "2025-10-14T10:20:35.965Z" },
+    { url = "https://files.pythonhosted.org/packages/83/6a/c070e30e295403bf29c4df1cb781317b6a9bac7cd07b8d3acc94d501a63c/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dd96e5d15385d301733113bcaa324c8bcf111275b7675a9c6e88bfb19fc05e3b", size = 2345169, upload-time = "2025-10-14T10:20:37.627Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/83/06d001f8043c336baea7fd202a9ac7ad71f87e1c55d8112c50b745c40324/pydantic_core-2.41.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98f348cbb44fae6e9653c1055db7e29de67ea6a9ca03a5fa2c2e11a47cff0e47", size = 2070165, upload-time = "2025-10-14T10:20:39.246Z" },
+    { url = "https://files.pythonhosted.org/packages/14/0a/e567c2883588dd12bcbc110232d892cf385356f7c8a9910311ac997ab715/pydantic_core-2.41.4-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ec22626a2d14620a83ca583c6f5a4080fa3155282718b6055c2ea48d3ef35970", size = 2189067, upload-time = "2025-10-14T10:20:41.015Z" },
+    { url = "https://files.pythonhosted.org/packages/f4/1d/3d9fca34273ba03c9b1c5289f7618bc4bd09c3ad2289b5420481aa051a99/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:3a95d4590b1f1a43bf33ca6d647b990a88f4a3824a8c4572c708f0b45a5290ed", size = 2132997, upload-time = "2025-10-14T10:20:43.106Z" },
+    { url = "https://files.pythonhosted.org/packages/52/70/d702ef7a6cd41a8afc61f3554922b3ed8d19dd54c3bd4bdbfe332e610827/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_armv7l.whl", hash = "sha256:f9672ab4d398e1b602feadcffcdd3af44d5f5e6ddc15bc7d15d376d47e8e19f8", size = 2307187, upload-time = "2025-10-14T10:20:44.849Z" },
+    { url = "https://files.pythonhosted.org/packages/68/4c/c06be6e27545d08b802127914156f38d10ca287a9e8489342793de8aae3c/pydantic_core-2.41.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:84d8854db5f55fead3b579f04bda9a36461dab0730c5d570e1526483e7bb8431", size = 2305204, upload-time = "2025-10-14T10:20:46.781Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/e5/35ae4919bcd9f18603419e23c5eaf32750224a89d41a8df1a3704b69f77e/pydantic_core-2.41.4-cp312-cp312-win32.whl", hash = "sha256:9be1c01adb2ecc4e464392c36d17f97e9110fbbc906bcbe1c943b5b87a74aabd", size = 1972536, upload-time = "2025-10-14T10:20:48.39Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/49c5bb6d2a49eb2ee3647a93e3dae7080c6409a8a7558b075027644e879c/pydantic_core-2.41.4-cp312-cp312-win_amd64.whl", hash = "sha256:d682cf1d22bab22a5be08539dca3d1593488a99998f9f412137bc323179067ff", size = 2031132, upload-time = "2025-10-14T10:20:50.421Z" },
+    { url = "https://files.pythonhosted.org/packages/06/23/936343dbcba6eec93f73e95eb346810fc732f71ba27967b287b66f7b7097/pydantic_core-2.41.4-cp312-cp312-win_arm64.whl", hash = "sha256:833eebfd75a26d17470b58768c1834dfc90141b7afc6eb0429c21fc5a21dcfb8", size = 1969483, upload-time = "2025-10-14T10:20:52.35Z" },
+    { url = "https://files.pythonhosted.org/packages/13/d0/c20adabd181a029a970738dfe23710b52a31f1258f591874fcdec7359845/pydantic_core-2.41.4-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:85e050ad9e5f6fe1004eec65c914332e52f429bc0ae12d6fa2092407a462c746", size = 2105688, upload-time = "2025-10-14T10:20:54.448Z" },
+    { url = "https://files.pythonhosted.org/packages/00/b6/0ce5c03cec5ae94cca220dfecddc453c077d71363b98a4bbdb3c0b22c783/pydantic_core-2.41.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:e7393f1d64792763a48924ba31d1e44c2cfbc05e3b1c2c9abb4ceeadd912cced", size = 1910807, upload-time = "2025-10-14T10:20:56.115Z" },
+    { url = "https://files.pythonhosted.org/packages/68/3e/800d3d02c8beb0b5c069c870cbb83799d085debf43499c897bb4b4aaff0d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94dab0940b0d1fb28bcab847adf887c66a27a40291eedf0b473be58761c9799a", size = 1956669, upload-time = "2025-10-14T10:20:57.874Z" },
+    { url = "https://files.pythonhosted.org/packages/60/a4/24271cc71a17f64589be49ab8bd0751f6a0a03046c690df60989f2f95c2c/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:de7c42f897e689ee6f9e93c4bec72b99ae3b32a2ade1c7e4798e690ff5246e02", size = 2051629, upload-time = "2025-10-14T10:21:00.006Z" },
+    { url = "https://files.pythonhosted.org/packages/68/de/45af3ca2f175d91b96bfb62e1f2d2f1f9f3b14a734afe0bfeff079f78181/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:664b3199193262277b8b3cd1e754fb07f2c6023289c815a1e1e8fb415cb247b1", size = 2224049, upload-time = "2025-10-14T10:21:01.801Z" },
+    { url = "https://files.pythonhosted.org/packages/af/8f/ae4e1ff84672bf869d0a77af24fd78387850e9497753c432875066b5d622/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d95b253b88f7d308b1c0b417c4624f44553ba4762816f94e6986819b9c273fb2", size = 2342409, upload-time = "2025-10-14T10:21:03.556Z" },
+    { url = "https://files.pythonhosted.org/packages/18/62/273dd70b0026a085c7b74b000394e1ef95719ea579c76ea2f0cc8893736d/pydantic_core-2.41.4-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1351f5bbdbbabc689727cb91649a00cb9ee7203e0a6e54e9f5ba9e22e384b84", size = 2069635, upload-time = "2025-10-14T10:21:05.385Z" },
+    { url = "https://files.pythonhosted.org/packages/30/03/cf485fff699b4cdaea469bc481719d3e49f023241b4abb656f8d422189fc/pydantic_core-2.41.4-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:1affa4798520b148d7182da0615d648e752de4ab1a9566b7471bc803d88a062d", size = 2194284, upload-time = "2025-10-14T10:21:07.122Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/7e/c8e713db32405dfd97211f2fc0a15d6bf8adb7640f3d18544c1f39526619/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:7b74e18052fea4aa8dea2fb7dbc23d15439695da6cbe6cfc1b694af1115df09d", size = 2137566, upload-time = "2025-10-14T10:21:08.981Z" },
+    { url = "https://files.pythonhosted.org/packages/04/f7/db71fd4cdccc8b75990f79ccafbbd66757e19f6d5ee724a6252414483fb4/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_armv7l.whl", hash = "sha256:285b643d75c0e30abda9dc1077395624f314a37e3c09ca402d4015ef5979f1a2", size = 2316809, upload-time = "2025-10-14T10:21:10.805Z" },
+    { url = "https://files.pythonhosted.org/packages/76/63/a54973ddb945f1bca56742b48b144d85c9fc22f819ddeb9f861c249d5464/pydantic_core-2.41.4-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:f52679ff4218d713b3b33f88c89ccbf3a5c2c12ba665fb80ccc4192b4608dbab", size = 2311119, upload-time = "2025-10-14T10:21:12.583Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/03/5d12891e93c19218af74843a27e32b94922195ded2386f7b55382f904d2f/pydantic_core-2.41.4-cp313-cp313-win32.whl", hash = "sha256:ecde6dedd6fff127c273c76821bb754d793be1024bc33314a120f83a3c69460c", size = 1981398, upload-time = "2025-10-14T10:21:14.584Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d8/fd0de71f39db91135b7a26996160de71c073d8635edfce8b3c3681be0d6d/pydantic_core-2.41.4-cp313-cp313-win_amd64.whl", hash = "sha256:d081a1f3800f05409ed868ebb2d74ac39dd0c1ff6c035b5162356d76030736d4", size = 2030735, upload-time = "2025-10-14T10:21:16.432Z" },
+    { url = "https://files.pythonhosted.org/packages/72/86/c99921c1cf6650023c08bfab6fe2d7057a5142628ef7ccfa9921f2dda1d5/pydantic_core-2.41.4-cp313-cp313-win_arm64.whl", hash = "sha256:f8e49c9c364a7edcbe2a310f12733aad95b022495ef2a8d653f645e5d20c1564", size = 1973209, upload-time = "2025-10-14T10:21:18.213Z" },
+    { url = "https://files.pythonhosted.org/packages/36/0d/b5706cacb70a8414396efdda3d72ae0542e050b591119e458e2490baf035/pydantic_core-2.41.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:ed97fd56a561f5eb5706cebe94f1ad7c13b84d98312a05546f2ad036bafe87f4", size = 1877324, upload-time = "2025-10-14T10:21:20.363Z" },
+    { url = "https://files.pythonhosted.org/packages/de/2d/cba1fa02cfdea72dfb3a9babb067c83b9dff0bbcb198368e000a6b756ea7/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a870c307bf1ee91fc58a9a61338ff780d01bfae45922624816878dce784095d2", size = 1884515, upload-time = "2025-10-14T10:21:22.339Z" },
+    { url = "https://files.pythonhosted.org/packages/07/ea/3df927c4384ed9b503c9cc2d076cf983b4f2adb0c754578dfb1245c51e46/pydantic_core-2.41.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d25e97bc1f5f8f7985bdc2335ef9e73843bb561eb1fa6831fdfc295c1c2061cf", size = 2042819, upload-time = "2025-10-14T10:21:26.683Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/ee/df8e871f07074250270a3b1b82aad4cd0026b588acd5d7d3eb2fcb1471a3/pydantic_core-2.41.4-cp313-cp313t-win_amd64.whl", hash = "sha256:d405d14bea042f166512add3091c1af40437c2e7f86988f3915fabd27b1e9cd2", size = 1995866, upload-time = "2025-10-14T10:21:28.951Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/de/b20f4ab954d6d399499c33ec4fafc46d9551e11dc1858fb7f5dca0748ceb/pydantic_core-2.41.4-cp313-cp313t-win_arm64.whl", hash = "sha256:19f3684868309db5263a11bace3c45d93f6f24afa2ffe75a647583df22a2ff89", size = 1970034, upload-time = "2025-10-14T10:21:30.869Z" },
+    { url = "https://files.pythonhosted.org/packages/54/28/d3325da57d413b9819365546eb9a6e8b7cbd9373d9380efd5f74326143e6/pydantic_core-2.41.4-cp314-cp314-macosx_10_12_x86_64.whl", hash = "sha256:e9205d97ed08a82ebb9a307e92914bb30e18cdf6f6b12ca4bedadb1588a0bfe1", size = 2102022, upload-time = "2025-10-14T10:21:32.809Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/24/b58a1bc0d834bf1acc4361e61233ee217169a42efbdc15a60296e13ce438/pydantic_core-2.41.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:82df1f432b37d832709fbcc0e24394bba04a01b6ecf1ee87578145c19cde12ac", size = 1905495, upload-time = "2025-10-14T10:21:34.812Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/a4/71f759cc41b7043e8ecdaab81b985a9b6cad7cec077e0b92cff8b71ecf6b/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc3b4cc4539e055cfa39a3763c939f9d409eb40e85813257dcd761985a108554", size = 1956131, upload-time = "2025-10-14T10:21:36.924Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/64/1e79ac7aa51f1eec7c4cda8cbe456d5d09f05fdd68b32776d72168d54275/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:b1eb1754fce47c63d2ff57fdb88c351a6c0150995890088b33767a10218eaa4e", size = 2052236, upload-time = "2025-10-14T10:21:38.927Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/e3/a3ffc363bd4287b80f1d43dc1c28ba64831f8dfc237d6fec8f2661138d48/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e6ab5ab30ef325b443f379ddb575a34969c333004fca5a1daa0133a6ffaad616", size = 2223573, upload-time = "2025-10-14T10:21:41.574Z" },
+    { url = "https://files.pythonhosted.org/packages/28/27/78814089b4d2e684a9088ede3790763c64693c3d1408ddc0a248bc789126/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:31a41030b1d9ca497634092b46481b937ff9397a86f9f51bd41c4767b6fc04af", size = 2342467, upload-time = "2025-10-14T10:21:44.018Z" },
+    { url = "https://files.pythonhosted.org/packages/92/97/4de0e2a1159cb85ad737e03306717637842c88c7fd6d97973172fb183149/pydantic_core-2.41.4-cp314-cp314-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a44ac1738591472c3d020f61c6df1e4015180d6262ebd39bf2aeb52571b60f12", size = 2063754, upload-time = "2025-10-14T10:21:46.466Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/50/8cb90ce4b9efcf7ae78130afeb99fd1c86125ccdf9906ef64b9d42f37c25/pydantic_core-2.41.4-cp314-cp314-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d72f2b5e6e82ab8f94ea7d0d42f83c487dc159c5240d8f83beae684472864e2d", size = 2196754, upload-time = "2025-10-14T10:21:48.486Z" },
+    { url = "https://files.pythonhosted.org/packages/34/3b/ccdc77af9cd5082723574a1cc1bcae7a6acacc829d7c0a06201f7886a109/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_aarch64.whl", hash = "sha256:c4d1e854aaf044487d31143f541f7aafe7b482ae72a022c664b2de2e466ed0ad", size = 2137115, upload-time = "2025-10-14T10:21:50.63Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/ba/e7c7a02651a8f7c52dc2cff2b64a30c313e3b57c7d93703cecea76c09b71/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_armv7l.whl", hash = "sha256:b568af94267729d76e6ee5ececda4e283d07bbb28e8148bb17adad93d025d25a", size = 2317400, upload-time = "2025-10-14T10:21:52.959Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/ba/6c533a4ee8aec6b812c643c49bb3bd88d3f01e3cebe451bb85512d37f00f/pydantic_core-2.41.4-cp314-cp314-musllinux_1_1_x86_64.whl", hash = "sha256:6d55fb8b1e8929b341cc313a81a26e0d48aa3b519c1dbaadec3a6a2b4fcad025", size = 2312070, upload-time = "2025-10-14T10:21:55.419Z" },
+    { url = "https://files.pythonhosted.org/packages/22/ae/f10524fcc0ab8d7f96cf9a74c880243576fd3e72bd8ce4f81e43d22bcab7/pydantic_core-2.41.4-cp314-cp314-win32.whl", hash = "sha256:5b66584e549e2e32a1398df11da2e0a7eff45d5c2d9db9d5667c5e6ac764d77e", size = 1982277, upload-time = "2025-10-14T10:21:57.474Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/dc/e5aa27aea1ad4638f0c3fb41132f7eb583bd7420ee63204e2d4333a3bbf9/pydantic_core-2.41.4-cp314-cp314-win_amd64.whl", hash = "sha256:557a0aab88664cc552285316809cab897716a372afaf8efdbef756f8b890e894", size = 2024608, upload-time = "2025-10-14T10:21:59.557Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/61/51d89cc2612bd147198e120a13f150afbf0bcb4615cddb049ab10b81b79e/pydantic_core-2.41.4-cp314-cp314-win_arm64.whl", hash = "sha256:3f1ea6f48a045745d0d9f325989d8abd3f1eaf47dd00485912d1a3a63c623a8d", size = 1967614, upload-time = "2025-10-14T10:22:01.847Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c2/472f2e31b95eff099961fa050c376ab7156a81da194f9edb9f710f68787b/pydantic_core-2.41.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:6c1fe4c5404c448b13188dd8bd2ebc2bdd7e6727fa61ff481bcc2cca894018da", size = 1876904, upload-time = "2025-10-14T10:22:04.062Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/07/ea8eeb91173807ecdae4f4a5f4b150a520085b35454350fc219ba79e66a3/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:523e7da4d43b113bf8e7b49fa4ec0c35bf4fe66b2230bfc5c13cc498f12c6c3e", size = 1882538, upload-time = "2025-10-14T10:22:06.39Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/29/b53a9ca6cd366bfc928823679c6a76c7a4c69f8201c0ba7903ad18ebae2f/pydantic_core-2.41.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5729225de81fb65b70fdb1907fcf08c75d498f4a6f15af005aabb1fdadc19dfa", size = 2041183, upload-time = "2025-10-14T10:22:08.812Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/3d/f8c1a371ceebcaf94d6dd2d77c6cf4b1c078e13a5837aee83f760b4f7cfd/pydantic_core-2.41.4-cp314-cp314t-win_amd64.whl", hash = "sha256:de2cfbb09e88f0f795fd90cf955858fc2c691df65b1f21f0aa00b99f3fbc661d", size = 1993542, upload-time = "2025-10-14T10:22:11.332Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/ac/9fc61b4f9d079482a290afe8d206b8f490e9fd32d4fc03ed4fc698214e01/pydantic_core-2.41.4-cp314-cp314t-win_arm64.whl", hash = "sha256:d34f950ae05a83e0ede899c595f312ca976023ea1db100cd5aa188f7005e3ab0", size = 1973897, upload-time = "2025-10-14T10:22:13.444Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/48/ae937e5a831b7c0dc646b2ef788c27cd003894882415300ed21927c21efa/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_10_12_x86_64.whl", hash = "sha256:4f5d640aeebb438517150fdeec097739614421900e4a08db4a3ef38898798537", size = 2112087, upload-time = "2025-10-14T10:22:56.818Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/db/6db8073e3d32dae017da7e0d16a9ecb897d0a4d92e00634916e486097961/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-macosx_11_0_arm64.whl", hash = "sha256:4a9ab037b71927babc6d9e7fc01aea9e66dc2a4a34dff06ef0724a4049629f94", size = 1920387, upload-time = "2025-10-14T10:22:59.342Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/c1/dd3542d072fcc336030d66834872f0328727e3b8de289c662faa04aa270e/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e4dab9484ec605c3016df9ad4fd4f9a390bc5d816a3b10c6550f8424bb80b18c", size = 1951495, upload-time = "2025-10-14T10:23:02.089Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/c6/db8d13a1f8ab3f1eb08c88bd00fd62d44311e3456d1e85c0e59e0a0376e7/pydantic_core-2.41.4-graalpy312-graalpy250_312_native-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bd8a5028425820731d8c6c098ab642d7b8b999758e24acae03ed38a66eca8335", size = 2139008, upload-time = "2025-10-14T10:23:04.539Z" },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.407"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a6/1b/0aa08ee42948b61745ac5b5b5ccaec4669e8884b53d31c8ec20b2fcd6b6f/pyright-1.1.407.tar.gz", hash = "sha256:099674dba5c10489832d4a4b2d302636152a9a42d317986c38474c76fe562262", size = 4122872, upload-time = "2025-10-24T23:17:15.145Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/93/b69052907d032b00c40cb656d21438ec00b3a471733de137a3f65a49a0a0/pyright-1.1.407-py3-none-any.whl", hash = "sha256:6dd419f54fcc13f03b52285796d65e639786373f433e243f8b94cf93a7444d21", size = 5997008, upload-time = "2025-10-24T23:17:13.159Z" },
+]
+
+[[package]]
+name = "pytokens"
+version = "0.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d4/c2/dbadcdddb412a267585459142bfd7cc241e6276db69339353ae6e241ab2b/pytokens-0.2.0.tar.gz", hash = "sha256:532d6421364e5869ea57a9523bf385f02586d4662acbcc0342afd69511b4dd43", size = 15368, upload-time = "2025-10-15T08:02:42.738Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/89/5a/c269ea6b348b6f2c32686635df89f32dbe05df1088dd4579302a6f8f99af/pytokens-0.2.0-py3-none-any.whl", hash = "sha256:74d4b318c67f4295c13782ddd9abcb7e297ec5630ad060eb90abf7ebbefe59f8", size = 12038, upload-time = "2025-10-15T08:02:41.694Z" },
+]
+
+[[package]]
+name = "ruff"
+version = "0.14.3"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/75/62/50b7727004dfe361104dfbf898c45a9a2fdfad8c72c04ae62900224d6ecf/ruff-0.14.3.tar.gz", hash = "sha256:4ff876d2ab2b161b6de0aa1f5bd714e8e9b4033dc122ee006925fbacc4f62153", size = 5558687, upload-time = "2025-10-31T00:26:26.878Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ce/8e/0c10ff1ea5d4360ab8bfca4cb2c9d979101a391f3e79d2616c9bf348cd26/ruff-0.14.3-py3-none-linux_armv6l.whl", hash = "sha256:876b21e6c824f519446715c1342b8e60f97f93264012de9d8d10314f8a79c371", size = 12535613, upload-time = "2025-10-31T00:25:44.302Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/c8/6724f4634c1daf52409fbf13fefda64aa9c8f81e44727a378b7b73dc590b/ruff-0.14.3-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b6fd8c79b457bedd2abf2702b9b472147cd860ed7855c73a5247fa55c9117654", size = 12855812, upload-time = "2025-10-31T00:25:47.793Z" },
+    { url = "https://files.pythonhosted.org/packages/de/03/db1bce591d55fd5f8a08bb02517fa0b5097b2ccabd4ea1ee29aa72b67d96/ruff-0.14.3-py3-none-macosx_11_0_arm64.whl", hash = "sha256:71ff6edca490c308f083156938c0c1a66907151263c4abdcb588602c6e696a14", size = 11944026, upload-time = "2025-10-31T00:25:49.657Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/75/4f8dbd48e03272715d12c87dc4fcaaf21b913f0affa5f12a4e9c6f8a0582/ruff-0.14.3-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:786ee3ce6139772ff9272aaf43296d975c0217ee1b97538a98171bf0d21f87ed", size = 12356818, upload-time = "2025-10-31T00:25:51.949Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/9b/506ec5b140c11d44a9a4f284ea7c14ebf6f8b01e6e8917734a3325bff787/ruff-0.14.3-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:cd6291d0061811c52b8e392f946889916757610d45d004e41140d81fb6cd5ddc", size = 12336745, upload-time = "2025-10-31T00:25:54.248Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/e1/c560d254048c147f35e7f8131d30bc1f63a008ac61595cf3078a3e93533d/ruff-0.14.3-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a497ec0c3d2c88561b6d90f9c29f5ae68221ac00d471f306fa21fa4264ce5fcd", size = 13101684, upload-time = "2025-10-31T00:25:56.253Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/32/e310133f8af5cd11f8cc30f52522a3ebccc5ea5bff4b492f94faceaca7a8/ruff-0.14.3-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:e231e1be58fc568950a04fbe6887c8e4b85310e7889727e2b81db205c45059eb", size = 14535000, upload-time = "2025-10-31T00:25:58.397Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/a1/7b0470a22158c6d8501eabc5e9b6043c99bede40fa1994cadf6b5c2a61c7/ruff-0.14.3-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:469e35872a09c0e45fecf48dd960bfbce056b5db2d5e6b50eca329b4f853ae20", size = 14156450, upload-time = "2025-10-31T00:26:00.889Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/96/24bfd9d1a7f532b560dcee1a87096332e461354d3882124219bcaff65c09/ruff-0.14.3-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3d6bc90307c469cb9d28b7cfad90aaa600b10d67c6e22026869f585e1e8a2db0", size = 13568414, upload-time = "2025-10-31T00:26:03.291Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/e7/138b883f0dfe4ad5b76b58bf4ae675f4d2176ac2b24bdd81b4d966b28c61/ruff-0.14.3-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2f8a0bbcffcfd895df39c9a4ecd59bb80dca03dc43f7fb63e647ed176b741e", size = 13315293, upload-time = "2025-10-31T00:26:05.708Z" },
+    { url = "https://files.pythonhosted.org/packages/33/f4/c09bb898be97b2eb18476b7c950df8815ef14cf956074177e9fbd40b7719/ruff-0.14.3-py3-none-manylinux_2_31_riscv64.whl", hash = "sha256:678fdd7c7d2d94851597c23ee6336d25f9930b460b55f8598e011b57c74fd8c5", size = 13539444, upload-time = "2025-10-31T00:26:08.09Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/aa/b30a1db25fc6128b1dd6ff0741fa4abf969ded161599d07ca7edd0739cc0/ruff-0.14.3-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:1ec1ac071e7e37e0221d2f2dbaf90897a988c531a8592a6a5959f0603a1ecf5e", size = 12252581, upload-time = "2025-10-31T00:26:10.297Z" },
+    { url = "https://files.pythonhosted.org/packages/da/13/21096308f384d796ffe3f2960b17054110a9c3828d223ca540c2b7cc670b/ruff-0.14.3-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:afcdc4b5335ef440d19e7df9e8ae2ad9f749352190e96d481dc501b753f0733e", size = 12307503, upload-time = "2025-10-31T00:26:12.646Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/cc/a350bac23f03b7dbcde3c81b154706e80c6f16b06ff1ce28ed07dc7b07b0/ruff-0.14.3-py3-none-musllinux_1_2_i686.whl", hash = "sha256:7bfc42f81862749a7136267a343990f865e71fe2f99cf8d2958f684d23ce3dfa", size = 12675457, upload-time = "2025-10-31T00:26:15.044Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/76/46346029fa2f2078826bc88ef7167e8c198e58fe3126636e52f77488cbba/ruff-0.14.3-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:a65e448cfd7e9c59fae8cf37f9221585d3354febaad9a07f29158af1528e165f", size = 13403980, upload-time = "2025-10-31T00:26:17.81Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/a4/35f1ef68c4e7b236d4a5204e3669efdeefaef21f0ff6a456792b3d8be438/ruff-0.14.3-py3-none-win32.whl", hash = "sha256:f3d91857d023ba93e14ed2d462ab62c3428f9bbf2b4fbac50a03ca66d31991f7", size = 12500045, upload-time = "2025-10-31T00:26:20.503Z" },
+    { url = "https://files.pythonhosted.org/packages/03/15/51960ae340823c9859fb60c63301d977308735403e2134e17d1d2858c7fb/ruff-0.14.3-py3-none-win_amd64.whl", hash = "sha256:d7b7006ac0756306db212fd37116cce2bd307e1e109375e1c6c106002df0ae5f", size = 13594005, upload-time = "2025-10-31T00:26:22.533Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/73/4de6579bac8e979fca0a77e54dec1f1e011a0d268165eb8a9bc0982a6564/ruff-0.14.3-py3-none-win_arm64.whl", hash = "sha256:26eb477ede6d399d898791d01961e16b86f02bc2486d0d1a7a9bb2379d055dc1", size = 12590017, upload-time = "2025-10-31T00:26:24.52Z" },
+]
+
+[[package]]
+name = "sniffio"
+version = "1.3.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a2/87/a6771e1546d97e7e041b6ae58d80074f81b7d5121207425c964ddf5cfdbd/sniffio-1.3.1.tar.gz", hash = "sha256:f4324edc670a0f49750a81b895f35c3adb843cca46f0530f79fc1babb23789dc", size = 20372, upload-time = "2024-02-25T23:20:04.057Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl", hash = "sha256:2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2", size = 10235, upload-time = "2024-02-25T23:20:01.196Z" },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.15.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/72/94/1a15dd82efb362ac84269196e94cf00f187f7ed21c242792a923cdb1c61f/typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466", size = 109391, upload-time = "2025-08-25T13:49:26.313Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/18/67/36e9267722cc04a6b9f15c7f3441c2363321a3ea07da7ae0c0707beb2a9c/typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548", size = 44614, upload-time = "2025-08-25T13:49:24.86Z" },
+]
+
+[[package]]
+name = "typing-inspection"
+version = "0.4.2"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/55/e3/70399cb7dd41c10ac53367ae42139cf4b1ca5f36bb3dc6c9d33acdb43655/typing_inspection-0.4.2.tar.gz", hash = "sha256:ba561c48a67c5958007083d386c3295464928b01faa735ab8547c5692e87f464", size = 75949, upload-time = "2025-10-01T02:14:41.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dc/9b/47798a6c91d8bdb567fe2698fe81e0c6b7cb7ef4d13da4114b41d239f65d/typing_inspection-0.4.2-py3-none-any.whl", hash = "sha256:4ed1cacbdc298c220f1bd249ed5287caa16f34d44ef4e9c3d0cbad5b521545e7", size = 14611, upload-time = "2025-10-01T02:14:40.154Z" },
+]
+
+[[package]]
+name = "win32-setctime"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/b3/8f/705086c9d734d3b663af0e9bb3d4de6578d08f46b1b101c2442fd9aecaa2/win32_setctime-1.2.0.tar.gz", hash = "sha256:ae1fdf948f5640aae05c511ade119313fb6a30d7eabe25fef9764dca5873c4c0", size = 4867, upload-time = "2024-12-07T15:28:28.314Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e1/07/c6fe3ad3e685340704d314d765b7912993bcb8dc198f0e7a89382d37974b/win32_setctime-1.2.0-py3-none-any.whl", hash = "sha256:95d644c4e708aba81dc3704a116d8cbc974d70b3bdb8be1d150e36be6e9d1390", size = 4083, upload-time = "2024-12-07T15:28:26.465Z" },
+]
+
+[[package]]
+name = "yarl"
+version = "1.22.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "idna" },
+    { name = "multidict" },
+    { name = "propcache" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/57/63/0c6ebca57330cd313f6102b16dd57ffaf3ec4c83403dcb45dbd15c6f3ea1/yarl-1.22.0.tar.gz", hash = "sha256:bebf8557577d4401ba8bd9ff33906f1376c877aa78d1fe216ad01b4d6745af71", size = 187169, upload-time = "2025-10-06T14:12:55.963Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/75/ff/46736024fee3429b80a165a732e38e5d5a238721e634ab41b040d49f8738/yarl-1.22.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:e340382d1afa5d32b892b3ff062436d592ec3d692aeea3bef3a5cfe11bbf8c6f", size = 142000, upload-time = "2025-10-06T14:09:44.631Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/9a/b312ed670df903145598914770eb12de1bac44599549b3360acc96878df8/yarl-1.22.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f1e09112a2c31ffe8d80be1b0988fa6a18c5d5cad92a9ffbb1c04c91bfe52ad2", size = 94338, upload-time = "2025-10-06T14:09:46.372Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/f5/0601483296f09c3c65e303d60c070a5c19fcdbc72daa061e96170785bc7d/yarl-1.22.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:939fe60db294c786f6b7c2d2e121576628468f65453d86b0fe36cb52f987bd74", size = 94909, upload-time = "2025-10-06T14:09:48.648Z" },
+    { url = "https://files.pythonhosted.org/packages/60/41/9a1fe0b73dbcefce72e46cf149b0e0a67612d60bfc90fb59c2b2efdfbd86/yarl-1.22.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e1651bf8e0398574646744c1885a41198eba53dc8a9312b954073f845c90a8df", size = 372940, upload-time = "2025-10-06T14:09:50.089Z" },
+    { url = "https://files.pythonhosted.org/packages/17/7a/795cb6dfee561961c30b800f0ed616b923a2ec6258b5def2a00bf8231334/yarl-1.22.0-cp312-cp312-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:b8a0588521a26bf92a57a1705b77b8b59044cdceccac7151bd8d229e66b8dedb", size = 345825, upload-time = "2025-10-06T14:09:52.142Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/93/a58f4d596d2be2ae7bab1a5846c4d270b894958845753b2c606d666744d3/yarl-1.22.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:42188e6a615c1a75bcaa6e150c3fe8f3e8680471a6b10150c5f7e83f47cc34d2", size = 386705, upload-time = "2025-10-06T14:09:54.128Z" },
+    { url = "https://files.pythonhosted.org/packages/61/92/682279d0e099d0e14d7fd2e176bd04f48de1484f56546a3e1313cd6c8e7c/yarl-1.22.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f6d2cb59377d99718913ad9a151030d6f83ef420a2b8f521d94609ecc106ee82", size = 396518, upload-time = "2025-10-06T14:09:55.762Z" },
+    { url = "https://files.pythonhosted.org/packages/db/0f/0d52c98b8a885aeda831224b78f3be7ec2e1aa4a62091f9f9188c3c65b56/yarl-1.22.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:50678a3b71c751d58d7908edc96d332af328839eea883bb554a43f539101277a", size = 377267, upload-time = "2025-10-06T14:09:57.958Z" },
+    { url = "https://files.pythonhosted.org/packages/22/42/d2685e35908cbeaa6532c1fc73e89e7f2efb5d8a7df3959ea8e37177c5a3/yarl-1.22.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1e8fbaa7cec507aa24ea27a01456e8dd4b6fab829059b69844bd348f2d467124", size = 365797, upload-time = "2025-10-06T14:09:59.527Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/83/cf8c7bcc6355631762f7d8bdab920ad09b82efa6b722999dfb05afa6cfac/yarl-1.22.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:433885ab5431bc3d3d4f2f9bd15bfa1614c522b0f1405d62c4f926ccd69d04fa", size = 365535, upload-time = "2025-10-06T14:10:01.139Z" },
+    { url = "https://files.pythonhosted.org/packages/25/e1/5302ff9b28f0c59cac913b91fe3f16c59a033887e57ce9ca5d41a3a94737/yarl-1.22.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:b790b39c7e9a4192dc2e201a282109ed2985a1ddbd5ac08dc56d0e121400a8f7", size = 382324, upload-time = "2025-10-06T14:10:02.756Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/cd/4617eb60f032f19ae3a688dc990d8f0d89ee0ea378b61cac81ede3e52fae/yarl-1.22.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:31f0b53913220599446872d757257be5898019c85e7971599065bc55065dc99d", size = 383803, upload-time = "2025-10-06T14:10:04.552Z" },
+    { url = "https://files.pythonhosted.org/packages/59/65/afc6e62bb506a319ea67b694551dab4a7e6fb7bf604e9bd9f3e11d575fec/yarl-1.22.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:a49370e8f711daec68d09b821a34e1167792ee2d24d405cbc2387be4f158b520", size = 374220, upload-time = "2025-10-06T14:10:06.489Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3d/68bf18d50dc674b942daec86a9ba922d3113d8399b0e52b9897530442da2/yarl-1.22.0-cp312-cp312-win32.whl", hash = "sha256:70dfd4f241c04bd9239d53b17f11e6ab672b9f1420364af63e8531198e3f5fe8", size = 81589, upload-time = "2025-10-06T14:10:09.254Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/9a/6ad1a9b37c2f72874f93e691b2e7ecb6137fb2b899983125db4204e47575/yarl-1.22.0-cp312-cp312-win_amd64.whl", hash = "sha256:8884d8b332a5e9b88e23f60bb166890009429391864c685e17bd73a9eda9105c", size = 87213, upload-time = "2025-10-06T14:10:11.369Z" },
+    { url = "https://files.pythonhosted.org/packages/44/c5/c21b562d1680a77634d748e30c653c3ca918beb35555cff24986fff54598/yarl-1.22.0-cp312-cp312-win_arm64.whl", hash = "sha256:ea70f61a47f3cc93bdf8b2f368ed359ef02a01ca6393916bc8ff877427181e74", size = 81330, upload-time = "2025-10-06T14:10:13.112Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f3/d67de7260456ee105dc1d162d43a019ecad6b91e2f51809d6cddaa56690e/yarl-1.22.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:8dee9c25c74997f6a750cd317b8ca63545169c098faee42c84aa5e506c819b53", size = 139980, upload-time = "2025-10-06T14:10:14.601Z" },
+    { url = "https://files.pythonhosted.org/packages/01/88/04d98af0b47e0ef42597b9b28863b9060bb515524da0a65d5f4db160b2d5/yarl-1.22.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:01e73b85a5434f89fc4fe27dcda2aff08ddf35e4d47bbbea3bdcd25321af538a", size = 93424, upload-time = "2025-10-06T14:10:16.115Z" },
+    { url = "https://files.pythonhosted.org/packages/18/91/3274b215fd8442a03975ce6bee5fe6aa57a8326b29b9d3d56234a1dca244/yarl-1.22.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:22965c2af250d20c873cdbee8ff958fb809940aeb2e74ba5f20aaf6b7ac8c70c", size = 93821, upload-time = "2025-10-06T14:10:17.993Z" },
+    { url = "https://files.pythonhosted.org/packages/61/3a/caf4e25036db0f2da4ca22a353dfeb3c9d3c95d2761ebe9b14df8fc16eb0/yarl-1.22.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b4f15793aa49793ec8d1c708ab7f9eded1aa72edc5174cae703651555ed1b601", size = 373243, upload-time = "2025-10-06T14:10:19.44Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/9e/51a77ac7516e8e7803b06e01f74e78649c24ee1021eca3d6a739cb6ea49c/yarl-1.22.0-cp313-cp313-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:e5542339dcf2747135c5c85f68680353d5cb9ffd741c0f2e8d832d054d41f35a", size = 342361, upload-time = "2025-10-06T14:10:21.124Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/f8/33b92454789dde8407f156c00303e9a891f1f51a0330b0fad7c909f87692/yarl-1.22.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:5c401e05ad47a75869c3ab3e35137f8468b846770587e70d71e11de797d113df", size = 387036, upload-time = "2025-10-06T14:10:22.902Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/9a/c5db84ea024f76838220280f732970aa4ee154015d7f5c1bfb60a267af6f/yarl-1.22.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:243dda95d901c733f5b59214d28b0120893d91777cb8aa043e6ef059d3cddfe2", size = 397671, upload-time = "2025-10-06T14:10:24.523Z" },
+    { url = "https://files.pythonhosted.org/packages/11/c9/cd8538dc2e7727095e0c1d867bad1e40c98f37763e6d995c1939f5fdc7b1/yarl-1.22.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bec03d0d388060058f5d291a813f21c011041938a441c593374da6077fe21b1b", size = 377059, upload-time = "2025-10-06T14:10:26.406Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/b9/ab437b261702ced75122ed78a876a6dec0a1b0f5e17a4ac7a9a2482d8abe/yarl-1.22.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0748275abb8c1e1e09301ee3cf90c8a99678a4e92e4373705f2a2570d581273", size = 365356, upload-time = "2025-10-06T14:10:28.461Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/9d/8e1ae6d1d008a9567877b08f0ce4077a29974c04c062dabdb923ed98e6fe/yarl-1.22.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:47fdb18187e2a4e18fda2c25c05d8251a9e4a521edaed757fef033e7d8498d9a", size = 361331, upload-time = "2025-10-06T14:10:30.541Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/5a/09b7be3905962f145b73beb468cdd53db8aa171cf18c80400a54c5b82846/yarl-1.22.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c7044802eec4524fde550afc28edda0dd5784c4c45f0be151a2d3ba017daca7d", size = 382590, upload-time = "2025-10-06T14:10:33.352Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/7f/59ec509abf90eda5048b0bc3e2d7b5099dffdb3e6b127019895ab9d5ef44/yarl-1.22.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:139718f35149ff544caba20fce6e8a2f71f1e39b92c700d8438a0b1d2a631a02", size = 385316, upload-time = "2025-10-06T14:10:35.034Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/84/891158426bc8036bfdfd862fabd0e0fa25df4176ec793e447f4b85cf1be4/yarl-1.22.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:e1b51bebd221006d3d2f95fbe124b22b247136647ae5dcc8c7acafba66e5ee67", size = 374431, upload-time = "2025-10-06T14:10:37.76Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/49/03da1580665baa8bef5e8ed34c6df2c2aca0a2f28bf397ed238cc1bbc6f2/yarl-1.22.0-cp313-cp313-win32.whl", hash = "sha256:d3e32536234a95f513bd374e93d717cf6b2231a791758de6c509e3653f234c95", size = 81555, upload-time = "2025-10-06T14:10:39.649Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/ee/450914ae11b419eadd067c6183ae08381cfdfcb9798b90b2b713bbebddda/yarl-1.22.0-cp313-cp313-win_amd64.whl", hash = "sha256:47743b82b76d89a1d20b83e60d5c20314cbd5ba2befc9cda8f28300c4a08ed4d", size = 86965, upload-time = "2025-10-06T14:10:41.313Z" },
+    { url = "https://files.pythonhosted.org/packages/98/4d/264a01eae03b6cf629ad69bae94e3b0e5344741e929073678e84bf7a3e3b/yarl-1.22.0-cp313-cp313-win_arm64.whl", hash = "sha256:5d0fcda9608875f7d052eff120c7a5da474a6796fe4d83e152e0e4d42f6d1a9b", size = 81205, upload-time = "2025-10-06T14:10:43.167Z" },
+    { url = "https://files.pythonhosted.org/packages/88/fc/6908f062a2f77b5f9f6d69cecb1747260831ff206adcbc5b510aff88df91/yarl-1.22.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:719ae08b6972befcba4310e49edb1161a88cdd331e3a694b84466bd938a6ab10", size = 146209, upload-time = "2025-10-06T14:10:44.643Z" },
+    { url = "https://files.pythonhosted.org/packages/65/47/76594ae8eab26210b4867be6f49129861ad33da1f1ebdf7051e98492bf62/yarl-1.22.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:47d8a5c446df1c4db9d21b49619ffdba90e77c89ec6e283f453856c74b50b9e3", size = 95966, upload-time = "2025-10-06T14:10:46.554Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/ce/05e9828a49271ba6b5b038b15b3934e996980dd78abdfeb52a04cfb9467e/yarl-1.22.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:cfebc0ac8333520d2d0423cbbe43ae43c8838862ddb898f5ca68565e395516e9", size = 97312, upload-time = "2025-10-06T14:10:48.007Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/c5/7dffad5e4f2265b29c9d7ec869c369e4223166e4f9206fc2243ee9eea727/yarl-1.22.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4398557cbf484207df000309235979c79c4356518fd5c99158c7d38203c4da4f", size = 361967, upload-time = "2025-10-06T14:10:49.997Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b2/375b933c93a54bff7fc041e1a6ad2c0f6f733ffb0c6e642ce56ee3b39970/yarl-1.22.0-cp313-cp313t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:2ca6fd72a8cd803be290d42f2dec5cdcd5299eeb93c2d929bf060ad9efaf5de0", size = 323949, upload-time = "2025-10-06T14:10:52.004Z" },
+    { url = "https://files.pythonhosted.org/packages/66/50/bfc2a29a1d78644c5a7220ce2f304f38248dc94124a326794e677634b6cf/yarl-1.22.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ca1f59c4e1ab6e72f0a23c13fca5430f889634166be85dbf1013683e49e3278e", size = 361818, upload-time = "2025-10-06T14:10:54.078Z" },
+    { url = "https://files.pythonhosted.org/packages/46/96/f3941a46af7d5d0f0498f86d71275696800ddcdd20426298e572b19b91ff/yarl-1.22.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:6c5010a52015e7c70f86eb967db0f37f3c8bd503a695a49f8d45700144667708", size = 372626, upload-time = "2025-10-06T14:10:55.767Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/42/8b27c83bb875cd89448e42cd627e0fb971fa1675c9ec546393d18826cb50/yarl-1.22.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9d7672ecf7557476642c88497c2f8d8542f8e36596e928e9bcba0e42e1e7d71f", size = 341129, upload-time = "2025-10-06T14:10:57.985Z" },
+    { url = "https://files.pythonhosted.org/packages/49/36/99ca3122201b382a3cf7cc937b95235b0ac944f7e9f2d5331d50821ed352/yarl-1.22.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:3b7c88eeef021579d600e50363e0b6ee4f7f6f728cd3486b9d0f3ee7b946398d", size = 346776, upload-time = "2025-10-06T14:10:59.633Z" },
+    { url = "https://files.pythonhosted.org/packages/85/b4/47328bf996acd01a4c16ef9dcd2f59c969f495073616586f78cd5f2efb99/yarl-1.22.0-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:f4afb5c34f2c6fecdcc182dfcfc6af6cccf1aa923eed4d6a12e9d96904e1a0d8", size = 334879, upload-time = "2025-10-06T14:11:01.454Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/ad/b77d7b3f14a4283bffb8e92c6026496f6de49751c2f97d4352242bba3990/yarl-1.22.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:59c189e3e99a59cf8d83cbb31d4db02d66cda5a1a4374e8a012b51255341abf5", size = 350996, upload-time = "2025-10-06T14:11:03.452Z" },
+    { url = "https://files.pythonhosted.org/packages/81/c8/06e1d69295792ba54d556f06686cbd6a7ce39c22307100e3fb4a2c0b0a1d/yarl-1.22.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:5a3bf7f62a289fa90f1990422dc8dff5a458469ea71d1624585ec3a4c8d6960f", size = 356047, upload-time = "2025-10-06T14:11:05.115Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/b8/4c0e9e9f597074b208d18cef227d83aac36184bfbc6eab204ea55783dbc5/yarl-1.22.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:de6b9a04c606978fdfe72666fa216ffcf2d1a9f6a381058d4378f8d7b1e5de62", size = 342947, upload-time = "2025-10-06T14:11:08.137Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/e5/11f140a58bf4c6ad7aca69a892bff0ee638c31bea4206748fc0df4ebcb3a/yarl-1.22.0-cp313-cp313t-win32.whl", hash = "sha256:1834bb90991cc2999f10f97f5f01317f99b143284766d197e43cd5b45eb18d03", size = 86943, upload-time = "2025-10-06T14:11:10.284Z" },
+    { url = "https://files.pythonhosted.org/packages/31/74/8b74bae38ed7fe6793d0c15a0c8207bbb819cf287788459e5ed230996cdd/yarl-1.22.0-cp313-cp313t-win_amd64.whl", hash = "sha256:ff86011bd159a9d2dfc89c34cfd8aff12875980e3bd6a39ff097887520e60249", size = 93715, upload-time = "2025-10-06T14:11:11.739Z" },
+    { url = "https://files.pythonhosted.org/packages/69/66/991858aa4b5892d57aef7ee1ba6b4d01ec3b7eb3060795d34090a3ca3278/yarl-1.22.0-cp313-cp313t-win_arm64.whl", hash = "sha256:7861058d0582b847bc4e3a4a4c46828a410bca738673f35a29ba3ca5db0b473b", size = 83857, upload-time = "2025-10-06T14:11:13.586Z" },
+    { url = "https://files.pythonhosted.org/packages/46/b3/e20ef504049f1a1c54a814b4b9bed96d1ac0e0610c3b4da178f87209db05/yarl-1.22.0-cp314-cp314-macosx_10_13_universal2.whl", hash = "sha256:34b36c2c57124530884d89d50ed2c1478697ad7473efd59cfd479945c95650e4", size = 140520, upload-time = "2025-10-06T14:11:15.465Z" },
+    { url = "https://files.pythonhosted.org/packages/e4/04/3532d990fdbab02e5ede063676b5c4260e7f3abea2151099c2aa745acc4c/yarl-1.22.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:0dd9a702591ca2e543631c2a017e4a547e38a5c0f29eece37d9097e04a7ac683", size = 93504, upload-time = "2025-10-06T14:11:17.106Z" },
+    { url = "https://files.pythonhosted.org/packages/11/63/ff458113c5c2dac9a9719ac68ee7c947cb621432bcf28c9972b1c0e83938/yarl-1.22.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:594fcab1032e2d2cc3321bb2e51271e7cd2b516c7d9aee780ece81b07ff8244b", size = 94282, upload-time = "2025-10-06T14:11:19.064Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/bc/315a56aca762d44a6aaaf7ad253f04d996cb6b27bad34410f82d76ea8038/yarl-1.22.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f3d7a87a78d46a2e3d5b72587ac14b4c16952dd0887dbb051451eceac774411e", size = 372080, upload-time = "2025-10-06T14:11:20.996Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/3f/08e9b826ec2e099ea6e7c69a61272f4f6da62cb5b1b63590bb80ca2e4a40/yarl-1.22.0-cp314-cp314-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:852863707010316c973162e703bddabec35e8757e67fcb8ad58829de1ebc8590", size = 338696, upload-time = "2025-10-06T14:11:22.847Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/9f/90360108e3b32bd76789088e99538febfea24a102380ae73827f62073543/yarl-1.22.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:131a085a53bfe839a477c0845acf21efc77457ba2bcf5899618136d64f3303a2", size = 387121, upload-time = "2025-10-06T14:11:24.889Z" },
+    { url = "https://files.pythonhosted.org/packages/98/92/ab8d4657bd5b46a38094cfaea498f18bb70ce6b63508fd7e909bd1f93066/yarl-1.22.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:078a8aefd263f4d4f923a9677b942b445a2be970ca24548a8102689a3a8ab8da", size = 394080, upload-time = "2025-10-06T14:11:27.307Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/e7/d8c5a7752fef68205296201f8ec2bf718f5c805a7a7e9880576c67600658/yarl-1.22.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bca03b91c323036913993ff5c738d0842fc9c60c4648e5c8d98331526df89784", size = 372661, upload-time = "2025-10-06T14:11:29.387Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/2e/f4d26183c8db0bb82d491b072f3127fb8c381a6206a3a56332714b79b751/yarl-1.22.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:68986a61557d37bb90d3051a45b91fa3d5c516d177dfc6dd6f2f436a07ff2b6b", size = 364645, upload-time = "2025-10-06T14:11:31.423Z" },
+    { url = "https://files.pythonhosted.org/packages/80/7c/428e5812e6b87cd00ee8e898328a62c95825bf37c7fa87f0b6bb2ad31304/yarl-1.22.0-cp314-cp314-musllinux_1_2_armv7l.whl", hash = "sha256:4792b262d585ff0dff6bcb787f8492e40698443ec982a3568c2096433660c694", size = 355361, upload-time = "2025-10-06T14:11:33.055Z" },
+    { url = "https://files.pythonhosted.org/packages/ec/2a/249405fd26776f8b13c067378ef4d7dd49c9098d1b6457cdd152a99e96a9/yarl-1.22.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:ebd4549b108d732dba1d4ace67614b9545b21ece30937a63a65dd34efa19732d", size = 381451, upload-time = "2025-10-06T14:11:35.136Z" },
+    { url = "https://files.pythonhosted.org/packages/67/a8/fb6b1adbe98cf1e2dd9fad71003d3a63a1bc22459c6e15f5714eb9323b93/yarl-1.22.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:f87ac53513d22240c7d59203f25cc3beac1e574c6cd681bbfd321987b69f95fd", size = 383814, upload-time = "2025-10-06T14:11:37.094Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/f9/3aa2c0e480fb73e872ae2814c43bc1e734740bb0d54e8cb2a95925f98131/yarl-1.22.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:22b029f2881599e2f1b06f8f1db2ee63bd309e2293ba2d566e008ba12778b8da", size = 370799, upload-time = "2025-10-06T14:11:38.83Z" },
+    { url = "https://files.pythonhosted.org/packages/50/3c/af9dba3b8b5eeb302f36f16f92791f3ea62e3f47763406abf6d5a4a3333b/yarl-1.22.0-cp314-cp314-win32.whl", hash = "sha256:6a635ea45ba4ea8238463b4f7d0e721bad669f80878b7bfd1f89266e2ae63da2", size = 82990, upload-time = "2025-10-06T14:11:40.624Z" },
+    { url = "https://files.pythonhosted.org/packages/ac/30/ac3a0c5bdc1d6efd1b41fa24d4897a4329b3b1e98de9449679dd327af4f0/yarl-1.22.0-cp314-cp314-win_amd64.whl", hash = "sha256:0d6e6885777af0f110b0e5d7e5dda8b704efed3894da26220b7f3d887b839a79", size = 88292, upload-time = "2025-10-06T14:11:42.578Z" },
+    { url = "https://files.pythonhosted.org/packages/df/0a/227ab4ff5b998a1b7410abc7b46c9b7a26b0ca9e86c34ba4b8d8bc7c63d5/yarl-1.22.0-cp314-cp314-win_arm64.whl", hash = "sha256:8218f4e98d3c10d683584cb40f0424f4b9fd6e95610232dd75e13743b070ee33", size = 82888, upload-time = "2025-10-06T14:11:44.863Z" },
+    { url = "https://files.pythonhosted.org/packages/06/5e/a15eb13db90abd87dfbefb9760c0f3f257ac42a5cac7e75dbc23bed97a9f/yarl-1.22.0-cp314-cp314t-macosx_10_13_universal2.whl", hash = "sha256:45c2842ff0e0d1b35a6bf1cd6c690939dacb617a70827f715232b2e0494d55d1", size = 146223, upload-time = "2025-10-06T14:11:46.796Z" },
+    { url = "https://files.pythonhosted.org/packages/18/82/9665c61910d4d84f41a5bf6837597c89e665fa88aa4941080704645932a9/yarl-1.22.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:d947071e6ebcf2e2bee8fce76e10faca8f7a14808ca36a910263acaacef08eca", size = 95981, upload-time = "2025-10-06T14:11:48.845Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/9a/2f65743589809af4d0a6d3aa749343c4b5f4c380cc24a8e94a3c6625a808/yarl-1.22.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:334b8721303e61b00019474cc103bdac3d7b1f65e91f0bfedeec2d56dfe74b53", size = 97303, upload-time = "2025-10-06T14:11:50.897Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/ab/5b13d3e157505c43c3b43b5a776cbf7b24a02bc4cccc40314771197e3508/yarl-1.22.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1e7ce67c34138a058fd092f67d07a72b8e31ff0c9236e751957465a24b28910c", size = 361820, upload-time = "2025-10-06T14:11:52.549Z" },
+    { url = "https://files.pythonhosted.org/packages/fb/76/242a5ef4677615cf95330cfc1b4610e78184400699bdda0acb897ef5e49a/yarl-1.22.0-cp314-cp314t-manylinux2014_armv7l.manylinux_2_17_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:d77e1b2c6d04711478cb1c4ab90db07f1609ccf06a287d5607fcd90dc9863acf", size = 323203, upload-time = "2025-10-06T14:11:54.225Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/96/475509110d3f0153b43d06164cf4195c64d16999e0c7e2d8a099adcd6907/yarl-1.22.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:c4647674b6150d2cae088fc07de2738a84b8bcedebef29802cf0b0a82ab6face", size = 363173, upload-time = "2025-10-06T14:11:56.069Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/66/59db471aecfbd559a1fd48aedd954435558cd98c7d0da8b03cc6c140a32c/yarl-1.22.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:efb07073be061c8f79d03d04139a80ba33cbd390ca8f0297aae9cce6411e4c6b", size = 373562, upload-time = "2025-10-06T14:11:58.783Z" },
+    { url = "https://files.pythonhosted.org/packages/03/1f/c5d94abc91557384719da10ff166b916107c1b45e4d0423a88457071dd88/yarl-1.22.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e51ac5435758ba97ad69617e13233da53908beccc6cfcd6c34bbed8dcbede486", size = 339828, upload-time = "2025-10-06T14:12:00.686Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/97/aa6a143d3afba17b6465733681c70cf175af89f76ec8d9286e08437a7454/yarl-1.22.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:33e32a0dd0c8205efa8e83d04fc9f19313772b78522d1bdc7d9aed706bfd6138", size = 347551, upload-time = "2025-10-06T14:12:02.628Z" },
+    { url = "https://files.pythonhosted.org/packages/43/3c/45a2b6d80195959239a7b2a8810506d4eea5487dce61c2a3393e7fc3c52e/yarl-1.22.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:bf4a21e58b9cde0e401e683ebd00f6ed30a06d14e93f7c8fd059f8b6e8f87b6a", size = 334512, upload-time = "2025-10-06T14:12:04.871Z" },
+    { url = "https://files.pythonhosted.org/packages/86/a0/c2ab48d74599c7c84cb104ebd799c5813de252bea0f360ffc29d270c2caa/yarl-1.22.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:e4b582bab49ac33c8deb97e058cd67c2c50dac0dd134874106d9c774fd272529", size = 352400, upload-time = "2025-10-06T14:12:06.624Z" },
+    { url = "https://files.pythonhosted.org/packages/32/75/f8919b2eafc929567d3d8411f72bdb1a2109c01caaab4ebfa5f8ffadc15b/yarl-1.22.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:0b5bcc1a9c4839e7e30b7b30dd47fe5e7e44fb7054ec29b5bb8d526aa1041093", size = 357140, upload-time = "2025-10-06T14:12:08.362Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/72/6a85bba382f22cf78add705d8c3731748397d986e197e53ecc7835e76de7/yarl-1.22.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c0232bce2170103ec23c454e54a57008a9a72b5d1c3105dc2496750da8cfa47c", size = 341473, upload-time = "2025-10-06T14:12:10.994Z" },
+    { url = "https://files.pythonhosted.org/packages/35/18/55e6011f7c044dc80b98893060773cefcfdbf60dfefb8cb2f58b9bacbd83/yarl-1.22.0-cp314-cp314t-win32.whl", hash = "sha256:8009b3173bcd637be650922ac455946197d858b3630b6d8787aa9e5c4564533e", size = 89056, upload-time = "2025-10-06T14:12:13.317Z" },
+    { url = "https://files.pythonhosted.org/packages/f9/86/0f0dccb6e59a9e7f122c5afd43568b1d31b8ab7dda5f1b01fb5c7025c9a9/yarl-1.22.0-cp314-cp314t-win_amd64.whl", hash = "sha256:9fb17ea16e972c63d25d4a97f016d235c78dd2344820eb35bc034bc32012ee27", size = 96292, upload-time = "2025-10-06T14:12:15.398Z" },
+    { url = "https://files.pythonhosted.org/packages/48/b7/503c98092fb3b344a179579f55814b613c1fbb1c23b3ec14a7b008a66a6e/yarl-1.22.0-cp314-cp314t-win_arm64.whl", hash = "sha256:9f6d73c1436b934e3f01df1e1b21ff765cd1d28c77dfb9ace207f746d4610ee1", size = 85171, upload-time = "2025-10-06T14:12:16.935Z" },
+    { url = "https://files.pythonhosted.org/packages/73/ae/b48f95715333080afb75a4504487cbe142cae1268afc482d06692d605ae6/yarl-1.22.0-py3-none-any.whl", hash = "sha256:1380560bdba02b6b6c90de54133c81c9f2a453dee9912fe58c1dcced1edb7cff", size = 46814, upload-time = "2025-10-06T14:12:53.872Z" },
+]

target/rust-analyzer/flycheck0/stderr

@@ -0,0 +1 @@
+    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.13s

target/rust-analyzer/flycheck0/stdout

@@ -0,0 +1,525 @@
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.103","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro2-1.0.103/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro2-1.0.103/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","proc-macro"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro2-c2526afd3b95d9b7/build-script-build"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.103","linked_libs":[],"linked_paths":[],"cfgs":["wrap_proc_macro","proc_macro_span_location","proc_macro_span_file"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro2-dc5b59bf23e1cfb0/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-ident@1.0.20","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-ident-1.0.20/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_ident","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-ident-1.0.20/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_ident-f1c0f7cb8d2e950d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_ident-f1c0f7cb8d2e950d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#quote@1.0.41","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quote-1.0.41/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quote-1.0.41/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","proc-macro"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/quote-63c10b5fc1327b7e/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","rc","result","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde_core-d7217d32cbd0d227/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","derive","rc","serde_derive","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde-4e8f4b65b2951e94/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cfg_if","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcfg_if-0d06577c98329a83.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#version_check@0.9.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/version_check-0.9.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"version_check","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/version_check-0.9.5/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libversion_check-ea6887218707dfc6.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libversion_check-ea6887218707dfc6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","extra_traits","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libc-af26b483f3f56edc/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#typenum@1.19.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/typenum-40d4fdd79c1383cd/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#autocfg@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/autocfg-1.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"autocfg","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/autocfg-1.5.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libautocfg-e43f4f6a57543659.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libautocfg-e43f4f6a57543659.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#shlex@1.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/shlex-1.3.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"shlex","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/shlex-1.3.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libshlex-c8dfa7667705618f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libshlex-c8dfa7667705618f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot_core@0.9.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/parking_lot_core-fec74986131a3e4b/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro2@1.0.103","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro2-1.0.103/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"proc_macro2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro2-1.0.103/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","proc-macro"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro2-8dfc43b08a9933f7.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro2-8dfc43b08a9933f7.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#quote@1.0.41","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/quote-ddf20bb25101601c/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde_core-fff508339ee419e6/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228","linked_libs":[],"linked_paths":[],"cfgs":["if_docsrs_then_no_serde_core"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde-25f4d703cd1bf07c/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","linked_libs":[],"linked_paths":[],"cfgs":["freebsd12"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libc-5b9c6a9e0bfd637b/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#typenum@1.19.0","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/typenum-f68f558ad7616dfe/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#generic-array@0.14.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/build.rs","edition":"2015","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["more_lengths"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/generic-array-232a401e09692621/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#find-msvc-tools@0.1.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/find-msvc-tools-0.1.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"find_msvc_tools","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/find-msvc-tools-0.1.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfind_msvc_tools-861c40af47356a5a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfind_msvc_tools-861c40af47356a5a.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot_core@0.9.12","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/parking_lot_core-9e6d734a2c639a66/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#memchr@2.7.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.7.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"memchr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.7.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmemchr-ac8810823885e36e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-project-lite-0.2.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pin_project_lite","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-project-lite-0.2.16/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_project_lite-0e86af28d48f0ea3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.15","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.15/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"itoa","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.15/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libitoa-ceaaf064462b8b6f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#quote@1.0.41","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quote-1.0.41/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"quote","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quote-1.0.41/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","proc-macro"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libquote-fff003355797a2eb.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libquote-fff003355797a2eb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","rc","result","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_core-bfc94944f44c39c1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"libc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","extra_traits","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibc-4ae08a1ad5ce0106.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cc@1.2.43","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cc-1.2.43/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cc-1.2.43/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcc-16042665004ba5bb.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcc-16042665004ba5bb.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#generic-array@0.14.9","linked_libs":[],"linked_paths":[],"cfgs":["relaxed_coherence","ga_is_deprecated"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/generic-array-4cbf8e2f13740c20/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bytes@1.10.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.10.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bytes","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.10.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbytes-ea8af492080e3cde.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-core-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-core-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_core-b17a82b164bf052b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#scopeguard@1.2.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/scopeguard-1.2.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"scopeguard","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/scopeguard-1.2.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libscopeguard-94e7e756cd69aad0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/once_cell-1.21.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"once_cell","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/once_cell-1.21.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","race","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libonce_cell-199800b58c1e0d8f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/icu_properties_data-341eb17399e67d52/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libc-500d20659087556a/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/icu_normalizer_data-02b3286e562902a4/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#syn@2.0.108","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-2.0.108/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"syn","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-2.0.108/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["clone-impls","default","derive","extra-traits","fold","full","parsing","printing","proc-macro","visit","visit-mut"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsyn-e9c9881e339b433f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsyn-e9c9881e339b433f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","dev_urandom_fallback"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/ring-ad505417dd295d3a/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#lock_api@0.4.14","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lock_api-0.4.14/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"lock_api","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lock_api-0.4.14/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["atomic_usize","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblock_api-0bbffb1f73cad42b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#log@0.4.28","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.28/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"log","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.28/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblog-e925b7c7149eae94.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.0.1","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/icu_properties_data-68ef7f1b98d542f4/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.0.0","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/icu_normalizer_data-156959387bc0deb0/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","linked_libs":[],"linked_paths":[],"cfgs":["freebsd12"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libc-87d4b14a55c2f179/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","i128","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/num-traits-504921570bd8326f/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-sink-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_sink","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-sink-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_sink-05ea9def2ed4c1f0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#stable_deref_trait@1.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stable_deref_trait-1.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"stable_deref_trait","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stable_deref_trait-1.2.1/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstable_deref_trait-0f09d0a9e9fcf1af.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#stable_deref_trait@1.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stable_deref_trait-1.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"stable_deref_trait","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stable_deref_trait-1.2.1/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstable_deref_trait-7f772b5f20238811.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstable_deref_trait-7f772b5f20238811.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#equivalent@1.0.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equivalent-1.0.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"equivalent","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equivalent-1.0.2/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libequivalent-f8f7e9459c1fce4f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_derive@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_derive-1.0.228/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"serde_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_derive-1.0.228/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_derive-4ff3872ad1d115a2.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#synstructure@0.13.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/synstructure-0.13.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"synstructure","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/synstructure-0.13.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","proc-macro"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsynstructure-27ce3f893c7e8744.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsynstructure-27ce3f893c7e8744.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerovec-derive@0.11.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-derive-0.11.1/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"zerovec_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-derive-0.11.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerovec_derive-852b9451c9e78719.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#displaydoc@0.2.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/displaydoc-0.2.5/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"displaydoc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/displaydoc-0.2.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdisplaydoc-80f168c19b14232c.so"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14","linked_libs":["static=ring_core_0_17_14_","static=ring_core_0_17_14__test"],"linked_paths":["native=/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/ring-47b50260cc061b5f/out"],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/ring-47b50260cc061b5f/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing-attributes@0.1.30","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-attributes-0.1.30/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"tracing_attributes","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-attributes-0.1.30/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_attributes-75feb328bcbfc11c.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libc@0.2.177","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"libc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libc-0.2.177/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibc-9d8d61b76418d581.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibc-9d8d61b76418d581.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","linked_libs":[],"linked_paths":[],"cfgs":["has_total_cmp"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/num-traits-2740c82699b93ce3/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio-macros@2.6.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-macros-2.6.0/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"tokio_macros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-macros-2.6.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_macros-10ec788be51e7929.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mio@1.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mio-1.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"mio","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mio-1.1.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["net","os-ext","os-poll"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmio-69cc6f61a748750d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#signal-hook-registry@1.4.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/signal-hook-registry-1.4.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"signal_hook_registry","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/signal-hook-registry-1.4.6/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsignal_hook_registry-279fe06f49766878.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"socket2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.6.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["all"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsocket2-99f47cebfc68c6ce.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","derive","rc","serde_derive","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde-0d7a3feebb3fac00.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerofrom-derive@0.1.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-derive-0.1.6/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"zerofrom_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-derive-0.1.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerofrom_derive-8882cc0cc9b6d6bf.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#yoke-derive@0.8.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-derive-0.8.0/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"yoke_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-derive-0.8.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libyoke_derive-b8296fc208466c93.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_core@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_core-1.0.228/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","rc","result","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_core-d9a245a13d0cae54.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_core-d9a245a13d0cae54.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cfg-if@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cfg_if","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcfg_if-3903d4ea2f60f4e9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcfg_if-3903d4ea2f60f4e9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crossbeam-utils-90212a47424a6c67/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"num_traits","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","i128","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_traits-717f96c832465ed3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashbrown@0.16.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.16.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashbrown","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.16.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-74a3e1b553adae99.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fnv@1.0.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fnv-1.0.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"fnv","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fnv-1.0.7/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfnv-2f01830a992dc6e2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#getrandom@0.2.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.2.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"getrandom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.2.16/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgetrandom-36c0e8df6dee3c6e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.34","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-core-0.1.34/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-core-0.1.34/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","once_cell","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_core-ac9bebbeb078cb6f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#typenum@1.19.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"typenum","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtypenum-8edf86967a48442c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.15.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"smallvec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.15.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["const_generics","const_new","serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsmallvec-4b31c63cbda92221.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-0.1.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerofrom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-0.1.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerofrom-71d0d42889cc9ca9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerofrom@0.1.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-0.1.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerofrom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerofrom-0.1.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerofrom-86092185c5f75bc8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerofrom-86092185c5f75bc8.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crossbeam-utils-8247c1ba485a304f/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde@1.0.228","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde-1.0.228/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","derive","rc","serde_derive","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde-8fca9d5a5564d171.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde-8fca9d5a5564d171.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#indexmap@2.12.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.12.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"indexmap","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.12.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libindexmap-6981210a9c484e8d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#slab@0.4.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/slab-0.4.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"slab","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/slab-0.4.11/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libslab-42e319f38072c981.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.145","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","raw_value","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde_json-73d6bbd8544b8d38/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#generic-array@0.14.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"generic_array","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["more_lengths"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgeneric_array-2ac6893a5d7b37df.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#equivalent@1.0.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equivalent-1.0.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"equivalent","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equivalent-1.0.2/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libequivalent-e3e55a7112a7f99e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libequivalent-e3e55a7112a7f99e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/thiserror-55630d289fe835da/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pin-utils@0.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-utils-0.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pin_utils","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-utils-0.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_utils-e3f5a18815d2cac2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot_core@0.9.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking_lot_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot_core-2405369acef26f21.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"yoke","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive","zerofrom"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libyoke-8201bbade4af29f7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#yoke@0.8.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"yoke","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/yoke-0.8.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive","zerofrom"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libyoke-0af4be52d1dbc69f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libyoke-0af4be52d1dbc69f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_utils","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_utils-51464d383ca9eddc.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.145","linked_libs":[],"linked_paths":[],"cfgs":["fast_arithmetic=\"64\""],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/serde_json-c0c57eeb1eccefc9/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.17","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/thiserror-8d9485f38595e92d/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.41","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-0.1.41/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-0.1.41/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["attributes","default","log","std","tracing-attributes"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing-34806e92b7cb692e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror-impl@2.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-impl-2.0.17/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"thiserror_impl","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-impl-2.0.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror_impl-5d67146ee57fe2c0.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#typenum@1.19.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"typenum","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/typenum-1.19.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtypenum-3dc4fa7dee969109.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtypenum-3dc4fa7dee969109.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#subtle@2.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"subtle","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsubtle-a133f89a6f137a1a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#memchr@2.7.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.7.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"memchr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/memchr-2.7.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmemchr-922a473a227244b5.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmemchr-922a473a227244b5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#block-buffer@0.10.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"block_buffer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libblock_buffer-17c3698cb709b54c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot@0.12.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot-0.12.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking_lot","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot-0.12.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot-567c4da2eb726cd4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-0.11.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerovec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-0.11.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive","yoke"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerovec-b7ab119a89dccb38.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerovec@0.11.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-0.11.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerovec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerovec-0.11.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","derive","yoke"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerovec-1b6029d6678c27c1.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerovec-1b6029d6678c27c1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#generic-array@0.14.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"generic_array","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.9/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["more_lengths"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgeneric_array-0f7f0e33460b89de.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgeneric_array-0f7f0e33460b89de.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crypto-common@0.1.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crypto_common","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrypto_common-5c29839ce1430b97.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#smallvec@1.15.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.15.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"smallvec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/smallvec-1.15.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["const_generics","serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsmallvec-045b76095471da4c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsmallvec-045b76095471da4c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-macro@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-macro-0.3.31/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"futures_macro","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-macro-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_macro-4812578d04daa375.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-task-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_task","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-task-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_task-c688eff9bf0e8af6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/writeable-0.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"writeable","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/writeable-0.6.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwriteable-7fd0e8655a97a0d9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#writeable@0.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/writeable-0.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"writeable","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/writeable-0.6.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwriteable-d1ec6715e04ecbb6.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwriteable-d1ec6715e04ecbb6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/untrusted-0.9.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"untrusted","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/untrusted-0.9.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libuntrusted-ada53e80fdaa862b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashbrown@0.16.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.16.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashbrown","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.16.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-24eac5d7585d9e73.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-24eac5d7585d9e73.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio@1.48.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.48.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.48.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bytes","default","fs","full","io-std","io-util","libc","macros","mio","net","parking_lot","process","rt","rt-multi-thread","signal","signal-hook-registry","socket2","sync","time","tokio-macros"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio-90fa6a44effc3db0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinystr@0.8.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinystr-0.8.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinystr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinystr-0.8.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinystr-2acb9a208881455c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinystr@0.8.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinystr-0.8.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinystr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinystr-0.8.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinystr-914e6e9a39f6b135.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinystr-914e6e9a39f6b135.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#litemap@0.8.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/litemap-0.8.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"litemap","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/litemap-0.8.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblitemap-79c1cd118b69f519.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblitemap-79c1cd118b69f519.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#litemap@0.8.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/litemap-0.8.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"litemap","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/litemap-0.8.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblitemap-fa5f69ff97a53b59.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-io-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_io","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-io-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_io-8f0f9ff3812a0397.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#digest@0.10.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"digest","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","block-buffer","core-api","default","mac","std","subtle"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdigest-354b084695a51395.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#indexmap@2.12.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.12.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"indexmap","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/indexmap-2.12.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libindexmap-bdee6124cd35ee68.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libindexmap-bdee6124cd35ee68.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ring","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","dev_urandom_fallback"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libring-667fd76fbf5b9222.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#potential_utf@0.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/potential_utf-0.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"potential_utf","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/potential_utf-0.1.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpotential_utf-c1da207c3333e679.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#potential_utf@0.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/potential_utf-0.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"potential_utf","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/potential_utf-0.1.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpotential_utf-a673d0c510ca18cd.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpotential_utf-a673d0c510ca18cd.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerotrie-0.2.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerotrie","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerotrie-0.2.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["yoke","zerofrom"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerotrie-4349b36ba7086e15.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_locale_core-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_locale_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_locale_core-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_locale_core-046edeede3b11da0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-util-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_util","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-util-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","async-await","async-await-macro","default","futures-io","futures-macro","futures-sink","io","memchr","sink","slab","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_util-b99548485e3b9848.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_locale_core@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_locale_core-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_locale_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_locale_core-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["zerovec"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_locale_core-ea6d72b3fa691a79.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_locale_core-ea6d72b3fa691a79.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerotrie@0.2.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerotrie-0.2.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerotrie","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerotrie-0.2.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["yoke","zerofrom"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerotrie-13056883895c520c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerotrie-13056883895c520c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#either@1.15.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/either-1.15.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"either","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/either-1.15.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","serde","std","use_std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libeither-06f57be0377b9972.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#getrandom@0.2.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.2.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"getrandom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.2.16/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgetrandom-5c338ce99bcc127a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgetrandom-5c338ce99bcc127a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.34","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["ring","std","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustls-527e3e40743be3b0/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pin-project-lite@0.2.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-project-lite-0.2.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pin_project_lite","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-project-lite-0.2.16/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_project_lite-3e13482372d799a9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_project_lite-3e13482372d799a9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#subtle@2.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"subtle","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/subtle-2.6.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsubtle-3e5b81787dac4e25.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsubtle-3e5b81787dac4e25.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-core@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-core-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-core-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_core-82e574cc644a8e45.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_core-82e574cc644a8e45.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_collections-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_collections","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_collections-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_collections-51b41521d713bce9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_collections-51b41521d713bce9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_collections@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_collections-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_collections","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_collections-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_collections-6c96a3570428c3d0.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.34","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustls-c0ae06cae5cd91ca/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_provider-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_provider","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_provider-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["baked","zerotrie"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_provider-beeb2a603d76cc51.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_provider@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_provider-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_provider","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_provider-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["baked","zerotrie"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_provider-f71b1cca04154b7b.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_provider-f71b1cca04154b7b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#block-buffer@0.10.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"block_buffer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libblock_buffer-820b55e6d2763a65.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libblock_buffer-820b55e6d2763a65.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crypto-common@0.1.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crypto_common","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrypto_common-fc331cb9a6e2df94.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrypto_common-fc331cb9a6e2df94.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/percent-encoding-2.3.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"percent_encoding","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/percent-encoding-2.3.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpercent_encoding-c62866a235b4614b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#once_cell@1.21.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/once_cell-1.21.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"once_cell","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/once_cell-1.21.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","race","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libonce_cell-8d8f0f4e9d9a1d14.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libonce_cell-8d8f0f4e9d9a1d14.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bytes@1.10.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.10.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bytes","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytes-1.10.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbytes-035f7819ab0dbbb9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbytes-035f7819ab0dbbb9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zeroize-1.8.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zeroize","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zeroize-1.8.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzeroize-d9fd2522e44d5063.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzeroize-d9fd2522e44d5063.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["derive","simd","zerocopy-derive"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/zerocopy-ccd78bfe1c20a4b8/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#scopeguard@1.2.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/scopeguard-1.2.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"scopeguard","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/scopeguard-1.2.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libscopeguard-c5439ad8e4f575e7.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libscopeguard-c5439ad8e4f575e7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#itoa@1.0.15","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.15/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"itoa","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itoa-1.0.15/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libitoa-0c1e50469e6d7ed8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libitoa-0c1e50469e6d7ed8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crossbeam-utils-cf5cfa5d0e283ebe/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ryu@1.0.20","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ryu-1.0.20/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ryu","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ryu-1.0.20/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libryu-8c67b68f1e03a70b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#lock_api@0.4.14","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lock_api-0.4.14/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"lock_api","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lock_api-0.4.14/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["atomic_usize","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblock_api-b81b90735a18ba44.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblock_api-b81b90735a18ba44.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#digest@0.10.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"digest","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","block-buffer","core-api","default","mac","std","subtle"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdigest-a4ab8fc632ca9f38.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdigest-a4ab8fc632ca9f38.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#form_urlencoded@1.2.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/form_urlencoded-1.2.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"form_urlencoded","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/form_urlencoded-1.2.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libform_urlencoded-4ab59003a35d276c.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","linked_libs":[],"linked_paths":[],"cfgs":["zerocopy_core_error_1_81_0","zerocopy_diagnostic_on_unimplemented_1_78_0","zerocopy_generic_bounds_in_const_fn_1_61_0","zerocopy_target_has_atomics_1_60_0","zerocopy_aarch64_simd_1_59_0","zerocopy_panic_in_const_and_vec_try_reserve_1_57_0"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/zerocopy-9aeb6816693866db/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.13.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pki-types-1.13.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls_pki_types","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pki-types-1.13.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls_pki_types-6dffff89957e6ed9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls_pki_types-6dffff89957e6ed9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http@1.3.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-1.3.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-1.3.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp-52ac24c42ba9853e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_normalizer_data","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer_data-d2473f55c03a7556.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy-derive@0.8.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-derive-0.8.27/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"zerocopy_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-derive-0.8.27/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerocopy_derive-7fdd29ad6a22a53e.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-channel-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_channel","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-channel-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","futures-sink","sink","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_channel-72c7561542a4054c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_properties_data","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties_data-e05272786a6e1307.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crossbeam-utils-de2c9f765f7be224/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties_data@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_properties_data","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties_data-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties_data-2ff9d3bcaaacd10d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties_data-2ff9d3bcaaacd10d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer_data@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_normalizer_data","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer_data-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer_data-1db967fe4c6265de.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer_data-1db967fe4c6265de.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/num-traits-90ddd607cced2c1c/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-sink@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-sink-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_sink","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-sink-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_sink-5eab777bc22d82c4.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_sink-5eab777bc22d82c4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httparse-1.10.1/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httparse-1.10.1/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/httparse-a369f4806a928b1e/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerocopy","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["derive","simd","zerocopy-derive"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerocopy-33d6c0fb507476cf.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_properties","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties-d2bcaf5cf6da4cd4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_normalizer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer-c23ee2db29ae800b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio-util@0.7.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-util-0.7.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio_util","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-util-0.7.16/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["codec","default","io"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_util-17981b5e0588c426.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bitflags@2.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-2.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bitflags","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-2.10.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbitflags-cbac1ac88d5fd87e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pkg-config@0.3.32","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pkg-config-0.3.32/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pkg_config","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pkg-config-0.3.32/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpkg_config-b2a2450548ccee1c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpkg_config-b2a2450548ccee1c.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1","linked_libs":[],"linked_paths":[],"cfgs":["httparse_simd_neon_intrinsics","httparse_simd"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/httparse-2246c683a1e71a20/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-utils@0.8.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_utils","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-utils-0.8.21/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_utils-9dc685ac9f2a70ca.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_utils-9dc685ac9f2a70ca.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_normalizer@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_normalizer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_normalizer-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer-0f6b7d372019188c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_normalizer-0f6b7d372019188c.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","linked_libs":[],"linked_paths":[],"cfgs":["has_total_cmp"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/num-traits-b3d93f2b657ad0df/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#icu_properties@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"icu_properties","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/icu_properties-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties-c3c894960133d802.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libicu_properties-c3c894960133d802.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zeroize@1.8.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zeroize-1.8.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zeroize","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zeroize-1.8.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzeroize-33116c7383756969.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#untrusted@0.9.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/untrusted-0.9.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"untrusted","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/untrusted-0.9.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libuntrusted-8fefe2d8943838fb.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libuntrusted-8fefe2d8943838fb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["simd"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/zerocopy-7fc8b9c5ca1f71b4/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#percent-encoding@2.3.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/percent-encoding-2.3.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"percent_encoding","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/percent-encoding-2.3.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpercent_encoding-24bbbb573270a49d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpercent_encoding-24bbbb573270a49d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#vcpkg@0.2.15","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/vcpkg-0.2.15/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"vcpkg","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/vcpkg-0.2.15/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libvcpkg-2f768acb3351d65e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libvcpkg-2f768acb3351d65e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.2.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cpufeatures","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcpufeatures-db9b4f83f1ea6279.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#idna_adapter@1.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna_adapter-1.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"idna_adapter","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna_adapter-1.2.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna_adapter-323a01a0228bb7a5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#form_urlencoded@1.2.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/form_urlencoded-1.2.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"form_urlencoded","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/form_urlencoded-1.2.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libform_urlencoded-9e67bae40707a4a8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libform_urlencoded-9e67bae40707a4a8.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","linked_libs":[],"linked_paths":[],"cfgs":["zerocopy_core_error_1_81_0","zerocopy_diagnostic_on_unimplemented_1_78_0","zerocopy_generic_bounds_in_const_fn_1_61_0","zerocopy_target_has_atomics_1_60_0","zerocopy_aarch64_simd_1_59_0","zerocopy_panic_in_const_and_vec_try_reserve_1_57_0"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/zerocopy-fa17d61eb4c5e282/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#idna_adapter@1.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna_adapter-1.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"idna_adapter","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna_adapter-1.2.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["compiled_data"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna_adapter-bf52744966dc244c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna_adapter-bf52744966dc244c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libsqlite3-sys@0.30.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bundled","bundled_bindings","cc","pkg-config","unlock_notify","vcpkg"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libsqlite3-sys-de861868b9dfa96e/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-traits@0.2.19","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"num_traits","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-traits-0.2.19/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_traits-08e48830a83e1690.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_traits-08e48830a83e1690.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#httparse@1.10.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httparse-1.10.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"httparse","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httparse-1.10.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttparse-b652932b81b77c4c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ring@0.17.14","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ring","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ring-0.17.14/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","dev_urandom_fallback"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libring-f7f6efac16c6f6dc.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libring-f7f6efac16c6f6dc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-pki-types@1.13.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pki-types-1.13.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls_pki_types","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pki-types-1.13.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls_pki_types-21127f2700e84bca.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.145","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_json","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","raw_value","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_json-9315519e75b0365c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot_core@0.9.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking_lot_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot_core-0.9.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot_core-747e6fbda30a9a37.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot_core-747e6fbda30a9a37.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"thiserror","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror-beef81694bdd356d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror-beef81694bdd356d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-epoch@0.9.18","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_epoch","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-epoch-0.9.18/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_epoch-04870539cd2b8887.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mio@1.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mio-1.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"mio","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mio-1.1.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["net","os-ext","os-poll"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmio-8aca8e6410db7ff7.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmio-8aca8e6410db7ff7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#socket2@0.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"socket2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.6.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["all"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsocket2-b9ed47982721c329.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsocket2-b9ed47982721c329.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#utf8_iter@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8_iter-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"utf8_iter","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8_iter-1.0.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libutf8_iter-2379f75900dcbd97.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libutf8_iter-2379f75900dcbd97.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#simd-adler32@0.3.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/simd-adler32-0.3.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"simd_adler32","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/simd-adler32-0.3.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["const-generics","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsimd_adler32-c63262ff7a6dc7e8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-io@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-io-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_io","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-io-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_io-2d27e9ab1b6bed61.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_io-2d27e9ab1b6bed61.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ryu@1.0.20","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ryu-1.0.20/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ryu","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ryu-1.0.20/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libryu-4bc6fb6ee18d87e5.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libryu-4bc6fb6ee18d87e5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pin-utils@0.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-utils-0.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pin_utils","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pin-utils-0.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_utils-0e9104001c81a39c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpin_utils-0e9104001c81a39c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#utf8_iter@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8_iter-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"utf8_iter","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/utf8_iter-1.0.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libutf8_iter-7af36920edb0fdad.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#foldhash@0.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/foldhash-0.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"foldhash","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/foldhash-0.1.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfoldhash-90d27756df1863e2.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfoldhash-90d27756df1863e2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fnv@1.0.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fnv-1.0.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"fnv","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fnv-1.0.7/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfnv-88b2d3140a9c4675.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfnv-88b2d3140a9c4675.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#httpdate@1.0.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httpdate-1.0.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"httpdate","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/httpdate-1.0.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttpdate-6f7f6b494863ddbc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-task@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-task-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_task","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-task-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_task-516f101507130c29.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_task-516f101507130c29.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#allocator-api2@0.2.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/allocator-api2-0.2.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"allocator_api2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/allocator-api2-0.2.21/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liballocator_api2-2768a3745864b17e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liballocator_api2-2768a3745864b17e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#slab@0.4.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/slab-0.4.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"slab","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/slab-0.4.11/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libslab-b1c53485c20521df.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libslab-b1c53485c20521df.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rayon-core@1.13.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rayon-core-62753ae4fc53848b/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio@1.48.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.48.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-1.48.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bytes","default","fs","io-util","libc","mio","net","rt","socket2","sync","time"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio-6d5380d7c1fc10d7.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio-6d5380d7c1fc10d7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#idna@1.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-1.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"idna","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-1.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","compiled_data","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna-0e38d3374d9dd511.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#idna@1.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-1.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"idna","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-1.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","compiled_data","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna-8edddd7d21d98c4f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna-8edddd7d21d98c4f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking_lot@0.12.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot-0.12.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking_lot","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking_lot-0.12.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot-c0f3f5fd0a8a7b95.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking_lot-c0f3f5fd0a8a7b95.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.103.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.103.8/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","ring","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki-e9bb7234a278207e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki-e9bb7234a278207e.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#libsqlite3-sys@0.30.1","linked_libs":["static=sqlite3"],"linked_paths":["native=/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libsqlite3-sys-1a5ff65b7211adfa/out"],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/libsqlite3-sys-1a5ff65b7211adfa/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-deque@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-deque-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_deque","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-deque-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_deque-6739d05c985cdb55.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zerocopy@0.8.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zerocopy","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zerocopy-0.8.27/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["simd"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerocopy-7fca5cfe3cea01aa.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzerocopy-7fca5cfe3cea01aa.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#concurrent-queue@2.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/concurrent-queue-2.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"concurrent_queue","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/concurrent-queue-2.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libconcurrent_queue-201741c761e5ac66.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libconcurrent_queue-201741c761e5ac66.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rayon-core@1.13.0","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rayon-core-b8bb77b78cb319ca/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashbrown@0.15.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.15.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashbrown","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.15.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["allocator-api2","default","default-hasher","equivalent","inline-more","raw-entry"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-5e442db6c510b8d8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-5e442db6c510b8d8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-util@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-util-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_util","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-util-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","futures-io","futures-sink","io","memchr","sink","slab","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_util-65184f6235e55d8e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_util-65184f6235e55d8e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#webpki-roots@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki_roots","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-1.0.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-a7c590968b98d177.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-a7c590968b98d177.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing-core@0.1.34","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-core-0.1.34/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-core-0.1.34/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["once_cell","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_core-622444d888e580ee.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_core-622444d888e580ee.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#equator-macro@0.4.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equator-macro-0.4.2/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"equator_macro","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equator-macro-0.4.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libequator_macro-e7957e10f9d76a5b.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aho-corasick-1.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"aho_corasick","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aho-corasick-1.1.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["perf-literal","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libaho_corasick-549fb29f09559838.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking@2.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking-2.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking-2.2.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking-8a7ed650060937d6.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking-8a7ed650060937d6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#log@0.4.28","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.28/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"log","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/log-0.4.28/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblog-1e5c58d2ec1af6c3.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblog-1e5c58d2ec1af6c3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinyvec_macros@0.1.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec_macros-0.1.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinyvec_macros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec_macros-0.1.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec_macros-24ecd4aceea8ffef.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#strsim@0.11.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strsim-0.11.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"strsim","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strsim-0.11.1/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstrsim-e33648cf90903771.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstrsim-e33648cf90903771.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#winnow@0.7.13","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winnow-0.7.13/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"winnow","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winnow-0.7.13/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwinnow-da91a93d8455edab.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwinnow-da91a93d8455edab.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.22.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"base64","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.22.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbase64-e2d9f256589e70bc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ident_case@1.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ident_case-1.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ident_case","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ident_case-1.0.1/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libident_case-f4903f65efca3c91.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libident_case-f4903f65efca3c91.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#iana-time-zone@0.1.64","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/iana-time-zone-0.1.64/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"iana_time_zone","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/iana-time-zone-0.1.64/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["fallback"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libiana_time_zone-3a6de048a13abf32.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libiana_time_zone-3a6de048a13abf32.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cpufeatures@0.2.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cpufeatures","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcpufeatures-2efc13566f5cfc50.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcpufeatures-2efc13566f5cfc50.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc-catalog@2.4.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-catalog-2.4.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crc_catalog","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-catalog-2.4.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc_catalog-0f65ae1e12b3ee73.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc_catalog-0f65ae1e12b3ee73.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinyvec_macros@0.1.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec_macros-0.1.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinyvec_macros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec_macros-0.1.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec_macros-5a3ca3bd95280218.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec_macros-5a3ca3bd95280218.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-syntax-0.8.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex_syntax","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-syntax-0.8.8/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_syntax-56c52121cec28ce6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#webpki-roots@0.26.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.26.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki_roots","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.26.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-65766dbf0795b021.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-65766dbf0795b021.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#event-listener@5.4.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/event-listener-5.4.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"event_listener","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/event-listener-5.4.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","parking","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libevent_listener-5b5cf7cd2b302b0f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libevent_listener-5b5cf7cd2b302b0f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rayon-core@1.13.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rayon_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-core-1.13.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librayon_core-50f2b84338e61e90.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing@0.1.41","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-0.1.41/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-0.1.41/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["attributes","default","log","std","tracing-attributes"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing-8e00b79be0604a8e.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing-8e00b79be0604a8e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinyvec@1.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec-1.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinyvec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec-1.10.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","tinyvec_macros"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec-8940fa081888e5d9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#darling_core@0.20.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling_core-0.20.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"darling_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling_core-0.20.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["strsim","suggestions"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdarling_core-a76b86c425434e9a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdarling_core-a76b86c425434e9a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.42","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/chrono-0.4.42/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"chrono","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/chrono-0.4.42/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","clock","iana-time-zone","now","std","winapi","windows-link"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libchrono-ac6f45878f7e1961.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libchrono-ac6f45878f7e1961.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.13","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-automata-0.4.13/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex_automata","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-automata-0.4.13/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","dfa-build","dfa-onepass","dfa-search","hybrid","meta","nfa-backtrack","nfa-pikevm","nfa-thompson","perf-inline","perf-literal","perf-literal-multisubstring","perf-literal-substring","std","syntax","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment","unicode-word-boundary"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_automata-6ec906d92e15ebc2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sha2@0.10.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha2-0.10.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sha2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha2-0.10.9/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsha2-874dd5c930351a62.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsha2-874dd5c930351a62.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tinyvec@1.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec-1.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tinyvec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tinyvec-1.10.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","tinyvec_macros"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec-26a6f053975e55e8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtinyvec-26a6f053975e55e8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc@3.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-3.3.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-3.3.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc-7c071928210ef122.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc-7c071928210ef122.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#equator@0.4.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equator-0.4.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"equator","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/equator-0.4.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libequator-b9fc88b1559d111d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashlink@0.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashlink-0.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashlink","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashlink-0.10.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashlink-09270f96f4ad6edb.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashlink-09270f96f4ad6edb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_parser@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_parser-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_parser","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_parser-1.0.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_parser-0d38c0bf31897a3b.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_parser-0d38c0bf31897a3b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#url@2.5.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/url-2.5.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"url","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/url-2.5.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","serde","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liburl-a46602a214358e7a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liburl-a46602a214358e7a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio-stream@0.1.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-stream-0.1.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio_stream","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-stream-0.1.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","fs","time"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_stream-72346480ebea6384.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_stream-72346480ebea6384.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-intrusive@0.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-intrusive-0.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_intrusive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-intrusive-0.5.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","parking_lot","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_intrusive-763803770adca0e9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_intrusive-763803770adca0e9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#url@2.5.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/url-2.5.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"url","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/url-2.5.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","serde","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liburl-948b65fa95308ab8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.34","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["ring","std","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls-05c8af8fd2a4ef12.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls-05c8af8fd2a4ef12.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ppv-lite86@0.2.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ppv-lite86-0.2.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ppv_lite86","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ppv-lite86-0.2.21/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["simd","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libppv_lite86-e315455cf59d380a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libppv_lite86-e315455cf59d380a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_json@1.0.145","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_json","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_json-1.0.145/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","raw_value","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_json-6c3abfd813bf7e80.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_json-6c3abfd813bf7e80.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-queue@0.3.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-queue-0.3.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_queue","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-queue-0.3.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_queue-7fa982ae5f5bc011.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_queue-7fa982ae5f5bc011.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand_core@0.6.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.6.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.6.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","getrandom","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_core-da6db4ff98416a07.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_core-da6db4ff98416a07.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio-stream@0.1.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-stream-0.1.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio_stream","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-stream-0.1.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","fs","time"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_stream-44f275b960fbb039.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@2.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"thiserror","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-2.0.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror-e5c4d6b85926f31e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#either@1.15.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/either-1.15.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"either","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/either-1.15.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","serde","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libeither-34a70e88c8258338.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libeither-34a70e88c8258338.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-integer@0.1.46","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-integer-0.1.46/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"num_integer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-integer-0.1.46/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["i128","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_integer-3c1d2169b26b1220.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#spin@0.9.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/spin-0.9.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"spin","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/spin-0.9.8/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["barrier","default","lazy","lock_api","lock_api_crate","mutex","once","rwlock","spin_mutex"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libspin-2506ac0fd7f96eee.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#foldhash@0.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/foldhash-0.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"foldhash","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/foldhash-0.1.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfoldhash-feb18bfda76cd9e7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mime@0.3.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime-0.3.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"mime","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime-0.3.17/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmime-dda4856c401cbb86.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_datetime@0.7.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_datetime-0.7.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_datetime","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_datetime-0.7.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_datetime-a91c4ac261989ac8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_datetime-a91c4ac261989ac8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#base64@0.22.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.22.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"base64","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.22.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbase64-b414e4898d872bf5.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbase64-b414e4898d872bf5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#allocator-api2@0.2.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/allocator-api2-0.2.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"allocator_api2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/allocator-api2-0.2.21/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liballocator_api2-a22f0c0335f16551.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#adler2@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/adler2-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"adler2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/adler2-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libadler2-06568820ec9015e9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc32fast-1.5.0/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc32fast-1.5.0/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crc32fast-25705a1a0bfabd8f/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.100","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.100/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.100/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/anyhow-b3393d6712be2b66/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand_chacha@0.3.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_chacha-0.3.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand_chacha","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_chacha-0.3.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_chacha-ae5fb905d45b4450.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_chacha-ae5fb905d45b4450.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-bigint@0.4.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"num_bigint","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-bigint-0.4.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_bigint-66b61861cb4b1cc7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-normalization@0.1.24","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-normalization-0.1.24/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_normalization","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-normalization-0.1.24/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_normalization-7bd7900c7f94d8a8.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_normalization-7bd7900c7f94d8a8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#darling_macro@0.20.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling_macro-0.20.11/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"darling_macro","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling_macro-0.20.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdarling_macro-c9f339a91b3ff730.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#aligned-vec@0.6.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aligned-vec-0.6.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"aligned_vec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aligned-vec-0.6.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libaligned_vec-f1775750a75714c7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-core@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-core-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-core-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["_rt-tokio","_tls-rustls","_tls-rustls-ring-webpki","any","chrono","crc","default","json","migrate","offline","rustls","serde","serde_json","sha2","tokio","tokio-stream","webpki-roots"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_core-5875ec023c954fde.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_core-5875ec023c954fde.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.100","linked_libs":[],"linked_paths":[],"cfgs":["std_backtrace"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/anyhow-e1f554b474e8a16f/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashbrown@0.15.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.15.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashbrown","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashbrown-0.15.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["allocator-api2","default","default-hasher","equivalent","inline-more","raw-entry"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashbrown-3830a29421c45ab6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#miniz_oxide@0.8.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/miniz_oxide-0.8.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"miniz_oxide","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/miniz_oxide-0.8.9/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","simd","simd-adler32","with-alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libminiz_oxide-8a6910d222c20c6f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_edit@0.23.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_edit-0.23.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_edit","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_edit-0.23.7/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["parse"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_edit-03b2cdddebf7471f.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_edit-03b2cdddebf7471f.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0","linked_libs":[],"linked_paths":[],"cfgs":["stable_arm_crc32_intrinsics"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/crc32fast-6aef6fb31c903b96/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-normalization@0.1.24","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-normalization-0.1.24/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_normalization","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-normalization-0.1.24/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_normalization-96a9ff0a9bef9e3d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#webpki-roots@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki_roots","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-1.0.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-7802e4c9d1579044.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.103.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.103.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.103.8/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","ring","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki-e806849ca4c16319.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#atoi@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atoi-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"atoi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atoi-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libatoi-bed84770aa6b0085.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libatoi-bed84770aa6b0085.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-channel@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-channel-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_channel","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-channel-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","futures-sink","sink","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_channel-0fee4fe41c02387a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_channel-0fee4fe41c02387a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#spin@0.9.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/spin-0.9.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"spin","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/spin-0.9.8/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["barrier","default","lazy","lock_api","lock_api_crate","mutex","once","rwlock","spin_mutex"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libspin-66a0ecd6d9dea10d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libspin-66a0ecd6d9dea10d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_urlencoded@0.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_urlencoded-0.7.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_urlencoded","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_urlencoded-0.7.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_urlencoded-8f907a3f03197d25.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hmac@0.12.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hmac-0.12.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hmac","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hmac-0.12.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["reset"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhmac-2da3f97f2845dcb7.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhmac-2da3f97f2845dcb7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http-body@1.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-1.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http_body","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-1.0.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp_body-ee300e8c0401f7b0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#concurrent-queue@2.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/concurrent-queue-2.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"concurrent_queue","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/concurrent-queue-2.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libconcurrent_queue-90fb506b3b89d0b4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http@0.2.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-0.2.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-0.2.12/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp-a34f5ed7241333a7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#uncased@0.9.10","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/uncased-0.9.10/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/uncased-0.9.10/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/uncased-38b24aec9bd6760c/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error-attr@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-attr-1.0.4/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-attr-1.0.4/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro-error-attr-0ff54659f24af802/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#paste@1.0.15","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/paste-1.0.15/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/paste-1.0.15/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/paste-215bf128850fcb6d/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#iana-time-zone@0.1.64","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/iana-time-zone-0.1.64/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"iana_time_zone","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/iana-time-zone-0.1.64/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["fallback"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libiana_time_zone-250791ca2b0fd0fd.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.21.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.21.12/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.21.12/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["dangerous_configuration","default","log","logging","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustls-da7edd07b6b15196/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.3.4/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.3.4/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/getrandom-e5ac4d83c21b9f00/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#cfg_aliases@0.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg_aliases-0.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"cfg_aliases","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg_aliases-0.2.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcfg_aliases-4c174da7cc486c29.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcfg_aliases-4c174da7cc486c29.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#parking@2.2.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking-2.2.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"parking","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/parking-2.2.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libparking-cfdf91581e521555.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#built@0.7.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/built-0.7.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"built","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/built-0.7.7/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbuilt-0a114cab9efc63bc.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbuilt-0a114cab9efc63bc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#syn@1.0.109","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-1.0.109/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-1.0.109/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/syn-2aa7e673fecdaada/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-bidi@0.3.18","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-bidi-0.3.18/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_bidi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-bidi-0.3.18/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","hardcoded-data","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_bidi-4b8743f8ac6b1003.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-properties@0.1.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-properties-0.1.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_properties","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-properties-0.1.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","emoji","general-category"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_properties-777662731d0a2981.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_properties-777662731d0a2981.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustix-1.1.2/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustix-1.1.2/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","fs","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustix-c770bf5957e216bd/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc-catalog@2.4.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-catalog-2.4.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crc_catalog","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-catalog-2.4.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc_catalog-70b4a5402e2adcdb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-bidi@0.3.18","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-bidi-0.3.18/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_bidi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-bidi-0.3.18/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","hardcoded-data","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_bidi-9a65fc0578eb2c1d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_bidi-9a65fc0578eb2c1d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#atomic-waker@1.1.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atomic-waker-1.1.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"atomic_waker","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atomic-waker-1.1.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libatomic_waker-82767012afcabf64.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#arrayvec@0.7.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/arrayvec-0.7.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"arrayvec","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/arrayvec-0.7.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libarrayvec-35fc933439bd3416.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@1.0.69","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-1.0.69/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-1.0.69/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/thiserror-14edc43edb1485d2/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#heck@0.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/heck-0.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"heck","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/heck-0.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libheck-7af3b78169a7edcf.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libheck-7af3b78169a7edcf.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#stringprep@0.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stringprep-0.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"stringprep","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stringprep-0.1.5/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstringprep-d81ce0bb6bfcf581.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstringprep-d81ce0bb6bfcf581.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@1.0.69","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/thiserror-e3b29a19691cddd9/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#h2@0.4.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/h2-0.4.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"h2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/h2-0.4.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libh2-fa23e4becb8b4572.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#event-listener@5.4.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/event-listener-5.4.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"event_listener","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/event-listener-5.4.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","parking","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libevent_listener-ad557064aa2e4d64.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc@3.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-3.3.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crc","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc-3.3.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc-32c9cef469826d95.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#syn@1.0.109","linked_libs":[],"linked_paths":[],"cfgs":["syn_disable_nightly_tests"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/syn-2e3070b024422eb6/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rav1e@0.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rav1e-0.7.1/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rav1e-0.7.1/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["threading"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rav1e-81899eb023c3b453/build-script-build"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.2","linked_libs":[],"linked_paths":[],"cfgs":["static_assertions","lower_upper_exp_for_non_zero","rustc_diagnostics","linux_raw_dep","linux_raw","linux_like","linux_kernel"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustix-a06eedffdfc4d77f/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hkdf@0.12.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hkdf-0.12.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hkdf","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hkdf-0.12.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhkdf-4d5c600b65484569.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhkdf-4d5c600b65484569.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#paste@1.0.15","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/paste-7870a2f1f02ea5e4/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/getrandom-8b77c37f53000e72/out"}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.21.12","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustls-0442cd7540073d24/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#nix@0.30.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nix-0.30.1/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nix-0.30.1/build.rs","edition":"2021","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","feature","fs","user"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/nix-575818c241f6c58e/build-script-build"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error-attr@1.0.4","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro-error-attr-9273c0f262b49d85/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#chrono@0.4.42","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/chrono-0.4.42/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"chrono","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/chrono-0.4.42/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","clock","default","iana-time-zone","js-sys","now","oldtime","serde","std","wasm-bindgen","wasmbind","winapi","windows-link"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libchrono-89336b37d8ed7698.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#uncased@0.9.10","linked_libs":[],"linked_paths":[],"cfgs":["const_fn_transmute"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/uncased-61ee821bb78ccd4d/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#webpki-roots@0.26.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.26.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki_roots","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.26.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-5874f75f823d3d1b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.23.34","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.23.34/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["ring","std","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls-52bff7cbe1a6efd4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hashlink@0.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashlink-0.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hashlink","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hashlink-0.10.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhashlink-85f35e26bdb0d715.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-crate@3.4.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-crate-3.4.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"proc_macro_crate","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-crate-3.4.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro_crate-013602eae408109b.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro_crate-013602eae408109b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crc32fast@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc32fast-1.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crc32fast","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crc32fast-1.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrc32fast-5c4c9c179257ad42.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#flume@0.11.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flume-0.11.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"flume","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flume-0.11.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["async","futures-core","futures-sink"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libflume-89d912b4939656c9.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libflume-89d912b4939656c9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#anyhow@1.0.100","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.100/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"anyhow","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/anyhow-1.0.100/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libanyhow-6c9f42bbb9d233fa.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-rational@0.4.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-rational-0.4.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"num_rational","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-rational-0.4.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","num-bigint","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_rational-44b6d3f274074320.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand@0.8.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand-0.8.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand-0.8.5/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","getrandom","libc","rand_chacha","std","std_rng"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand-04338d61a0f793be.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand-04338d61a0f793be.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#darling@0.20.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling-0.20.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"darling","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/darling-0.20.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","suggestions"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdarling-c7bb68aa96b27dd0.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdarling-c7bb68aa96b27dd0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#v_frame@0.3.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/v_frame-0.3.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"v_frame","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/v_frame-0.3.9/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libv_frame-a06ddd5884229016.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rayon@1.11.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-1.11.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rayon","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rayon-1.11.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librayon-692d188f8f7349a7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-executor@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-executor-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_executor","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-executor-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_executor-7148f8800b732ec1.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_executor-7148f8800b732ec1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libsqlite3-sys@0.30.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"libsqlite3_sys","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bundled","bundled_bindings","cc","pkg-config","unlock_notify","vcpkg"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibsqlite3_sys-df0f3d4df9c6b043.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibsqlite3_sys-df0f3d4df9c6b043.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_urlencoded@0.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_urlencoded-0.7.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_urlencoded","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_urlencoded-0.7.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_urlencoded-037c07c721466afd.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_urlencoded-037c07c721466afd.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sha2@0.10.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha2-0.10.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sha2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha2-0.10.9/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsha2-aa1c36a33dfc414a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ppv-lite86@0.2.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ppv-lite86-0.2.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ppv_lite86","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ppv-lite86-0.2.21/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["simd","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libppv_lite86-4fb8d251b2634dd3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#md-5@0.10.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/md-5-0.10.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"md5","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/md-5-0.10.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmd5-660c2d8df5f41b52.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmd5-660c2d8df5f41b52.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sct@0.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sct-0.7.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sct","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sct-0.7.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsct-2b0af8966c1be8a3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-webpki@0.101.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.101.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-webpki-0.101.7/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki-4620974893086199.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-intrusive@0.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-intrusive-0.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_intrusive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-intrusive-0.5.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","parking_lot","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_intrusive-b2ec8060c02189fc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#aho-corasick@1.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aho-corasick-1.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"aho_corasick","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/aho-corasick-1.1.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["perf-literal","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libaho_corasick-f51db0490213ea7c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libaho_corasick-f51db0490213ea7c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#crossbeam-queue@0.3.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-queue-0.3.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"crossbeam_queue","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crossbeam-queue-0.3.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcrossbeam_queue-d58dde5aa95b384f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand_core@0.6.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.6.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_core-0.6.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","getrandom","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_core-ea97358a83314610.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#profiling-procmacros@1.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/profiling-procmacros-1.0.17/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"profiling_procmacros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/profiling-procmacros-1.0.17/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libprofiling_procmacros-bed57b9961bfec0f.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror-impl@1.0.69","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-impl-1.0.69/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"thiserror_impl","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-impl-1.0.69/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror_impl-f24da00b53c565aa.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#nom@8.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"nom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nom-8.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnom-c8ec707cd741ddd1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#encoding_rs@0.8.35","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/encoding_rs-0.8.35/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"encoding_rs","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/encoding_rs-0.8.35/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libencoding_rs-3a64e32416949d50.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#multer@3.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/multer-3.1.0/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/multer-3.1.0/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","tokio"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/multer-e714f6ea7b325f65/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-1.0.4/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-1.0.4/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","syn","syn-error"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro-error-75dd2576901ee3d8/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bitflags@2.10.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-2.10.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bitflags","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitflags-2.10.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbitflags-b38c1791fbb94bbd.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbitflags-b38c1791fbb94bbd.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#linux-raw-sys@0.11.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"linux_raw_sys","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/linux-raw-sys-0.11.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["auxvec","elf","errno","general","ioctl","no_std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblinux_raw_sys-e6b08a81801d5c43.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#try-lock@0.2.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/try-lock-0.2.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"try_lock","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/try-lock-0.2.5/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtry_lock-b39d2f1611e73d1b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#whoami@1.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/whoami-1.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"whoami","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/whoami-1.6.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwhoami-b6a1b5d2bc8a3076.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwhoami-b6a1b5d2bc8a3076.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#quick-error@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-error-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"quick_error","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-error-2.0.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libquick_error-1276212204d642e7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustversion@1.0.22","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustversion-1.0.22/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustversion-1.0.22/build/build.rs","edition":"2018","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustversion-b6a4c433fe390acc/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#dotenvy@0.15.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dotenvy-0.15.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"dotenvy","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dotenvy-0.15.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdotenvy-788d4127d6efe36a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdotenvy-788d4127d6efe36a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#byteorder@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-1.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"byteorder","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-1.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbyteorder-8e05bf1e8551efb4.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbyteorder-8e05bf1e8551efb4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hex@0.4.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hex-0.4.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hex","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hex-0.4.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhex-89c80fa6492a5e3a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhex-89c80fa6492a5e3a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicase@2.8.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicase-2.8.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicase","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicase-2.8.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicase-eee2bf5726ab06ad.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicase-eee2bf5726ab06ad.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#home@0.5.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/home-0.5.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"home","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/home-0.5.12/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhome-217f975b72a78412.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhome-217f975b72a78412.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex-syntax@0.8.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-syntax-0.8.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex_syntax","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-syntax-0.8.8/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_syntax-99e1576c8964a718.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_syntax-99e1576c8964a718.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error@1.0.4","linked_libs":[],"linked_paths":[],"cfgs":["use_fallback"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/proc-macro-error-1c3806fd5c9291ab/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thiserror@1.0.69","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-1.0.69/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"thiserror","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thiserror-1.0.69/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthiserror-4edcf18c1c2ebe4f.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustversion@1.0.22","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rustversion-1898eae5a255a4ec/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#want@0.3.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/want-0.3.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"want","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/want-0.3.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwant-8a8f417f4f52f03e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex-automata@0.4.13","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-automata-0.4.13/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex_automata","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-automata-0.4.13/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","dfa-onepass","hybrid","meta","nfa-backtrack","nfa-pikevm","nfa-thompson","perf-inline","perf-literal","perf-literal-multisubstring","perf-literal-substring","std","syntax","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment","unicode-word-boundary"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_automata-2acc034b1bc38ee4.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex_automata-2acc034b1bc38ee4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-postgres@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-postgres-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_postgres","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-postgres-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["chrono","json","migrate","offline"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_postgres-589bf25ea0d6821d.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_postgres-589bf25ea0d6821d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mime_guess@2.0.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime_guess-2.0.5/Cargo.toml","target":{"kind":["custom-build"],"crate_types":["bin"],"name":"build-script-build","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime_guess-2.0.5/build.rs","edition":"2015","doc":false,"doctest":false,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/mime_guess-5688dff3b4378d51/build-script-build"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-core@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-core-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-core-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["_rt-tokio","_tls-rustls","_tls-rustls-ring-webpki","any","chrono","crc","default","json","migrate","offline","rustls","serde","serde_json","sha2","tokio","tokio-stream","webpki-roots"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_core-c08bcbf786ebe0d5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#profiling@1.0.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/profiling-1.0.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"profiling","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/profiling-1.0.17/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","procmacros","profiling-procmacros"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libprofiling-4655970031b371cc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand_chacha@0.3.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_chacha-0.3.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand_chacha","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand_chacha-0.3.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand_chacha-b5e0c84584268410.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustix@1.1.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustix-1.1.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustix","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustix-1.1.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","fs","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustix-f824303872f46ad6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#av1-grain@0.2.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/av1-grain-0.2.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"av1_grain","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/av1-grain-0.2.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["create","default","diff","estimate","nom","num-rational","parse","v_frame"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libav1_grain-2673f1bbea504adf.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#multer@3.1.0","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/multer-a1c06a51a691d5b2/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls@0.21.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.21.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-0.21.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["dangerous_configuration","default","log","logging","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls-68efc21e6373ec29.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-sqlite@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-sqlite-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_sqlite","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-sqlite-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bundled","chrono","json","migrate","offline","serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_sqlite-96280727da982e4c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_sqlite-96280727da982e4c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#maybe-rayon@0.1.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/maybe-rayon-0.1.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"maybe_rayon","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/maybe-rayon-0.1.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["rayon","threads"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmaybe_rayon-fbef6c9fa6512533.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#uncased@0.9.10","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/uncased-0.9.10/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"uncased","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/uncased-0.9.10/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libuncased-a852b37f9e20c2e9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error-attr@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-attr-1.0.4/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"proc_macro_error_attr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-attr-1.0.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro_error_attr-8e73d7ec074b7e3e.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#flate2@1.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flate2-1.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"flate2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flate2-1.1.5/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["any_impl","default","miniz_oxide","rust_backend"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libflate2-7180dc037dd84587.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#nix@0.30.1","linked_libs":[],"linked_paths":[],"cfgs":["linux","linux_android"],"env":[],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/nix-f5eca5887ef76d5a/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#getrandom@0.3.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.3.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"getrandom","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/getrandom-0.3.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgetrandom-8454dfae14fac7e5.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#rav1e@0.7.1","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[["PROFILE","debug"],["CARGO_CFG_TARGET_FEATURE","fxsr,sse,sse2"],["CARGO_ENCODED_RUSTFLAGS",""]],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/rav1e-de591df25d62601c/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hyper@1.7.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-1.7.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hyper","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-1.7.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","http1","http2","server"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhyper-50406c4f25f8f009.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#paste@1.0.15","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/paste-1.0.15/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"paste","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/paste-1.0.15/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpaste-fa7cf8cc00705f0e.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#syn@1.0.109","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-1.0.109/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"syn","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/syn-1.0.109/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsyn-42a50529132e2641.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsyn-42a50529132e2641.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http-body@0.4.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-0.4.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http_body","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-0.4.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp_body-6903b0d1f0b1cff0.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#h2@0.3.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/h2-0.3.27/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"h2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/h2-0.3.27/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libh2-2cbd0ab6eb0e0e82.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex@1.12.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-1.12.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-1.12.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","perf","perf-backtrack","perf-cache","perf-dfa","perf-inline","perf-literal","perf-onepass","std","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex-c782ebe48772d9cb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sha1@0.10.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha1-0.10.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sha1","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sha1-0.10.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsha1-90855c870bc6d0d3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#half@2.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/half-2.7.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"half","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/half-2.7.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhalf-3ca0de8d441af7c2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#headers-core@0.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/headers-core-0.3.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"headers_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/headers-core-0.3.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libheaders_core-b86f90d193c2a2a2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#itertools@0.12.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itertools-0.12.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"itertools","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itertools-0.12.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","use_alloc","use_std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libitertools-606dbdf19e534467.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hmac@0.12.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hmac-0.12.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hmac","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hmac-0.12.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["reset"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhmac-c19da5083fc791eb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#atoi@2.0.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atoi-2.0.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"atoi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/atoi-2.0.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libatoi-53d405aa3eed9bb3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fax_derive@0.2.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fax_derive-0.2.0/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"fax_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fax_derive-0.2.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfax_derive-10be3c20e7683012.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#arg_enum_proc_macro@0.3.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/arg_enum_proc_macro-0.3.4/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"arg_enum_proc_macro","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/arg_enum_proc_macro-0.3.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libarg_enum_proc_macro-6e5bdaeb1eb6fa60.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#num-derive@0.4.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-derive-0.4.2/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"num_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/num-derive-0.4.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnum_derive-db6c7b7c32c435e2.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#simd_helpers@0.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/simd_helpers-0.1.0/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"simd_helpers","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/simd_helpers-0.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsimd_helpers-197785bf274cbf47.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#socket2@0.5.10","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.5.10/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"socket2","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/socket2-0.5.10/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["all"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsocket2-2a54f3965cbf6bf1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#imgref@1.12.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/imgref-1.12.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"imgref","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/imgref-1.12.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","deprecated"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libimgref-4c9a2283b3e22661.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#new_debug_unreachable@1.0.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/new_debug_unreachable-1.0.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"debug_unreachable","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/new_debug_unreachable-1.0.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdebug_unreachable-4ffae148293e93c2.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#weezl@0.1.10","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/weezl-0.1.10/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"weezl","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/weezl-0.1.10/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libweezl-09645a278c058032.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zune-core@0.4.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.4.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zune_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-core-0.4.12/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzune_core-9e3432a5f8b08f84.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-properties@0.1.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-properties-0.1.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_properties","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-properties-0.1.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","emoji","general-category"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_properties-5a8467642d5bc354.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bitstream-io@2.6.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitstream-io-2.6.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bitstream_io","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bitstream-io-2.6.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbitstream_io-3a29a176e9d291a1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#noop_proc_macro@0.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/noop_proc_macro-0.3.0/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"noop_proc_macro","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/noop_proc_macro-0.3.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnoop_proc_macro-c64e0a5eecfa5b81.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unsafe-libyaml@0.2.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unsafe-libyaml-0.2.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unsafe_libyaml","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unsafe-libyaml-0.2.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunsafe_libyaml-aa6f4aca066234fc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fastrand@2.3.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fastrand-2.3.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"fastrand","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fastrand-2.3.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfastrand-b8d51b4241328c12.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicode-xid@0.2.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-xid-0.2.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicode_xid","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicode-xid-0.2.6/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_xid-d82fa850bbc7339a.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicode_xid-d82fa850bbc7339a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tower-service@0.3.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tower-service-0.3.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tower_service","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tower-service-0.3.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtower_service-d71afa1094c1aff5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#derive_more-impl@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/derive_more-impl-2.0.1/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"derive_more_impl","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/derive_more-impl-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","display"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libderive_more_impl-b14230fc9adf31f5.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zune-jpeg@0.4.21","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-jpeg-0.4.21/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zune_jpeg","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-jpeg-0.4.21/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","neon","std","x86"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzune_jpeg-0447694149a6d8e3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#stringprep@0.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stringprep-0.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"stringprep","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/stringprep-0.1.5/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstringprep-8f2436607c818e01.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#loop9@0.1.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/loop9-0.1.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"loop9","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/loop9-0.1.5/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libloop9-7fd776861bd0f124.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tempfile@3.23.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.23.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tempfile","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tempfile-3.23.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","getrandom"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtempfile-3b016d900f5b58eb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_yaml@0.9.34+deprecated","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_yaml-0.9.34+deprecated/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_yaml","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_yaml-0.9.34+deprecated/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_yaml-5f598ab4523c07e4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rav1e@0.7.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rav1e-0.7.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rav1e","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rav1e-0.7.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["threading"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librav1e-7014114ed3e38e67.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hyper@0.14.32","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-0.14.32/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hyper","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-0.14.32/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["client","h2","http1","http2","runtime","socket2","tcp"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhyper-c8dd69d54db6f60e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fax@0.2.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fax-0.2.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"fax","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fax-0.2.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfax-33b8befac565ee4a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hkdf@0.12.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hkdf-0.12.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hkdf","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hkdf-0.12.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhkdf-798203649d3de711.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#headers@0.4.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/headers-0.4.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"headers","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/headers-0.4.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libheaders-6860b354e9caf10c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rfc7239@0.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rfc7239-0.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rfc7239","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rfc7239-0.1.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librfc7239-08266e9a31c2ce68.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#nix@0.30.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nix-0.30.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"nix","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nix-0.30.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","feature","fs","user"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnix-0a1d42f3116af415.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hyper-util@0.1.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-util-0.1.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hyper_util","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-util-0.1.17/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","http1","http2","server","server-auto","tokio"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhyper_util-60d441e0b5ae7016.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-macros-core@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-macros-core-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_macros_core","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-macros-core-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["_rt-tokio","_sqlite","_tls-rustls-ring-webpki","chrono","default","derive","json","macros","migrate","postgres","sqlite","sqlx-postgres","sqlx-sqlite","tokio"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_macros_core-c8a0da41c3f811a1.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_macros_core-c8a0da41c3f811a1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#proc-macro-error@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"proc_macro_error","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/proc-macro-error-1.0.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","syn","syn-error"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro_error-5575318de62adba4.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libproc_macro_error-5575318de62adba4.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#regex@1.12.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-1.12.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"regex","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/regex-1.12.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","perf","perf-backtrack","perf-cache","perf-dfa","perf-inline","perf-literal","perf-onepass","std","unicode","unicode-age","unicode-bool","unicode-case","unicode-gencat","unicode-perl","unicode-script","unicode-segment"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex-1d1794c7bf5d3307.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libregex-1d1794c7bf5d3307.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rand@0.8.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand-0.8.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rand","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rand-0.8.5/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","getrandom","libc","rand_chacha","std","std_rng"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librand-41d0fe7a9f21284e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustversion@1.0.22","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustversion-1.0.22/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"rustversion","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustversion-1.0.22/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustversion-795721cbadc38550.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#multer@3.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/multer-3.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"multer","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/multer-3.1.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","tokio"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmulter-51d2b40ff5339db6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tokio-rustls@0.24.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-rustls-0.24.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tokio_rustls","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tokio-rustls-0.24.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","logging","tls12"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtokio_rustls-34f3dc2435957b88.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-script-executed","package_id":"registry+https://github.com/rust-lang/crates.io-index#mime_guess@2.0.5","linked_libs":[],"linked_paths":[],"cfgs":[],"env":[["MIME_TYPES_GENERATED_PATH","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/mime_guess-1426f7b4882ecb31/out/mime_types_generated.rs"]],"out_dir":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/build/mime_guess-1426f7b4882ecb31/out"}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#poem-derive@3.1.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-derive-3.1.12/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"poem_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-derive-3.1.12/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpoem_derive-8e62601d9583b18d.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#avif-serialize@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/avif-serialize-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"avif_serialize","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/avif-serialize-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libavif_serialize-6468eccd38ebe9d1.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http-body-util@0.1.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-util-0.1.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http_body_util","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-body-util-0.1.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp_body_util-1725b6c714c8c930.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#flume@0.11.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flume-0.11.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"flume","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/flume-0.11.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["async","futures-core","futures-sink"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libflume-dd6282566df970f9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#libsqlite3-sys@0.30.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"libsqlite3_sys","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/libsqlite3-sys-0.30.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["bundled","bundled_bindings","cc","pkg-config","unlock_notify","vcpkg"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblibsqlite3_sys-372b9fae979149df.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#zune-inflate@0.2.54","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-inflate-0.2.54/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"zune_inflate","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/zune-inflate-0.2.54/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["simd-adler32","zlib"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libzune_inflate-7c5c58e887824126.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#http@1.3.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-1.3.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"http","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/http-1.3.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp-1e479c026371396c.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhttp-1e479c026371396c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#fdeflate@0.3.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fdeflate-0.3.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"fdeflate","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/fdeflate-0.3.7/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfdeflate-1261f2d0d5f0d6cc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#futures-executor@0.3.31","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-executor-0.3.31/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"futures_executor","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/futures-executor-0.3.31/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libfutures_executor-e118e0a0a93babfb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#md-5@0.10.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/md-5-0.10.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"md5","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/md-5-0.10.6/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmd5-9ceff60a39d46b6a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_datetime@0.6.11","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_datetime-0.6.11/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_datetime","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_datetime-0.6.11/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_datetime-07b4c84e71302367.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#quick-xml@0.36.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.36.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"quick_xml","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/quick-xml-0.36.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","serde","serialize"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libquick_xml-6c99d53523be101f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#serde_spanned@0.6.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_spanned-0.6.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"serde_spanned","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/serde_spanned-0.6.9/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libserde_spanned-e69e227d367aeaaf.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#pxfm@0.1.25","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pxfm-0.1.25/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"pxfm","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/pxfm-0.1.25/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpxfm-35161f77ec1fe1b9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@1.0.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sync_wrapper-1.0.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sync_wrapper","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sync_wrapper-1.0.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["futures","futures-core"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsync_wrapper-523213f0df8e7e54.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#byteorder-lite@0.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-lite-0.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"byteorder_lite","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-lite-0.1.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbyteorder_lite-f6540ef6f1d175ed.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bytemuck@1.24.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytemuck-1.24.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bytemuck","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bytemuck-1.24.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["extern_crate_alloc"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbytemuck-ac4e3d738cadd47b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_write@0.1.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_write-0.1.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_write","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_write-0.1.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_write-47a403c14aa3f32a.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#winnow@0.7.13","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winnow-0.7.13/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"winnow","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/winnow-0.7.13/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwinnow-cc879e89137baf86.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mime@0.3.17","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime-0.3.17/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"mime","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime-0.3.17/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmime-a5e715a4d463ceb6.rlib","/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmime-a5e715a4d463ceb6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#bit_field@0.10.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bit_field-0.10.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"bit_field","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/bit_field-0.10.3/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbit_field-cd31547248e3fae8.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#byteorder@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-1.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"byteorder","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/byteorder-1.5.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbyteorder-96b77cf0a259533b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#color_quant@1.1.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/color_quant-1.1.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"color_quant","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/color_quant-1.1.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libcolor_quant-c3ac9126f36f0bb5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#unicase@2.8.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicase-2.8.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"unicase","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/unicase-2.8.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libunicase-b702adde543582bc.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#wildmatch@2.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wildmatch-2.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"wildmatch","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/wildmatch-2.5.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwildmatch-ae7df3f41d957bba.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#lazy_static@1.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lazy_static-1.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"lazy_static","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lazy_static-1.5.0/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblazy_static-d550ab0b2fa2a527.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#lebe@0.5.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lebe-0.5.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"lebe","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/lebe-0.5.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/liblebe-7ff2d440580a02b3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#dotenvy@0.15.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dotenvy-0.15.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"dotenvy","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/dotenvy-0.15.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libdotenvy-2896eeba63939b58.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#home@0.5.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/home-0.5.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"home","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/home-0.5.12/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhome-e124a0cb758a2d1f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#whoami@1.6.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/whoami-1.6.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"whoami","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/whoami-1.6.1/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwhoami-974bb5e9f7f81c68.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hex@0.4.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hex-0.4.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hex","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hex-0.4.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhex-4ccaaced0dd5bf6b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#base64@0.21.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.21.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"base64","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/base64-0.21.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbase64-c5cb9a52f2075ae5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rgb@0.8.52","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rgb-0.8.52/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rgb","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rgb-0.8.52/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librgb-1ffa705445d9809f.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#gif@0.13.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/gif-0.13.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"gif","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/gif-0.13.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["color_quant","default","raii_no_panic","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libgif-fa20f5dc7a132e1e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#poem@3.1.12","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-3.1.12/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"poem","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-3.1.12/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","libtempfile","multer","multipart","quick-xml","serde_yaml","server","sse","tempfile","tokio-stream","xml","yaml"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpoem-7a1f70edfbf4e11b.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#mime_guess@2.0.5","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime_guess-2.0.5/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"mime_guess","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/mime_guess-2.0.5/src/lib.rs","edition":"2015","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmime_guess-5c5a50a6e4063629.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#qoi@0.4.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/qoi-0.4.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"qoi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/qoi-0.4.1/src/lib.rs","edition":"2021","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libqoi-0082349ec24e01c9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#image-webp@0.2.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/image-webp-0.2.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"image_webp","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/image-webp-0.2.4/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libimage_webp-2698678708e47d79.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-postgres@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-postgres-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_postgres","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-postgres-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["any","chrono","json","migrate"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_postgres-b986f7cdb2c3bd1d.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#exr@1.73.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/exr-1.73.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"exr","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/exr-1.73.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libexr-bf4d58b94e2774b5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ravif@0.11.20","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ravif-0.11.20/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ravif","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ravif-0.11.20/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["threading"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libravif-0f62560c4f585b71.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#rustls-pemfile@1.0.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pemfile-1.0.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"rustls_pemfile","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/rustls-pemfile-1.0.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/librustls_pemfile-8feada489c89a7a7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#poem-openapi-derive@5.1.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-openapi-derive-5.1.16/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"poem_openapi_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-openapi-derive-5.1.16/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpoem_openapi_derive-c26519603deae7d8.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml_edit@0.22.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_edit-0.22.27/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml_edit","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml_edit-0.22.27/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["display","parse","serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml_edit-2d252eb89cccea80.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sharded-slab@0.1.7","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sharded-slab-0.1.7/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sharded_slab","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sharded-slab-0.1.7/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsharded_slab-7541bf732f80f2f9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#png@0.18.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/png-0.18.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"png","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/png-0.18.0/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpng-a06b9c268fbf7810.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#moxcms@0.7.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/moxcms-0.7.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"moxcms","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/moxcms-0.7.9/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["avx","default","neon","sse"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmoxcms-cd24de23d60da821.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-sqlite@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-sqlite-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx_sqlite","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-sqlite-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["any","bundled","chrono","json","migrate","serde"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_sqlite-290a3067882febd5.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#hyper-rustls@0.24.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-rustls-0.24.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"hyper_rustls","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/hyper-rustls-0.24.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libhyper_rustls-5647f347a2f24298.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#validator_derive@0.18.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/validator_derive-0.18.2/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"validator_derive","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/validator_derive-0.18.2/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libvalidator_derive-bb8a88fb005b75d3.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#strum_macros@0.26.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strum_macros-0.26.4/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"strum_macros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strum_macros-0.26.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstrum_macros-8ba8a0fec53c96c4.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx-macros@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-macros-0.8.6/Cargo.toml","target":{"kind":["proc-macro"],"crate_types":["proc-macro"],"name":"sqlx_macros","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-macros-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":0,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["_rt-tokio","_tls-rustls-ring-webpki","chrono","default","derive","json","macros","migrate","postgres","sqlite"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx_macros-32d9617747d4fbb2.so"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tiff@0.10.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tiff-0.10.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tiff","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tiff-0.10.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","deflate","fax","jpeg","lzw"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtiff-4fbbffae1d4756ab.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#derive_more@2.0.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/derive_more-2.0.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"derive_more","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/derive_more-2.0.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","display","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libderive_more-7156f49b83a04b15.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#idna@0.5.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-0.5.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"idna","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/idna-0.5.0/src/lib.rs","edition":"2018","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libidna-e81bd76047fac226.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#matchers@0.2.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/matchers-0.2.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"matchers","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/matchers-0.2.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libmatchers-768ac95762c585c7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#itertools@0.14.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itertools-0.14.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"itertools","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/itertools-0.14.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":false},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","use_alloc","use_std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libitertools-834f62bf355f63b9.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing-log@0.2.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-log-0.2.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing_log","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-log-0.2.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["log-tracer","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_log-aeae6eacf11ed394.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#thread_local@1.1.9","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thread_local-1.1.9/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"thread_local","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/thread_local-1.1.9/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libthread_local-9b825e677f0561f6.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sync_wrapper@0.1.2","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sync_wrapper-0.1.2/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sync_wrapper","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sync_wrapper-0.1.2/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsync_wrapper-cc574eb954b2ae89.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#nu-ansi-term@0.50.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nu-ansi-term-0.50.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"nu_ansi_term","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/nu-ansi-term-0.50.3/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libnu_ansi_term-7a29ced857324d23.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#webpki-roots@0.25.4","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.25.4/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"webpki_roots","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/webpki-roots-0.25.4/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":[],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libwebpki_roots-91ee2910580bc06c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#ipnet@2.11.0","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ipnet-2.11.0/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"ipnet","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/ipnet-2.11.0/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","std"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libipnet-ce22f9624b648b97.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#image@0.25.8","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/image-0.25.8/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"image","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/image-0.25.8/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["avif","bmp","dds","default","default-formats","exr","ff","gif","hdr","ico","jpeg","png","pnm","qoi","rayon","tga","tiff","webp"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libimage-18b5eeda68aa2ccb.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#poem-openapi@5.1.16","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-openapi-5.1.16/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"poem_openapi","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/poem-openapi-5.1.16/src/lib.rs","edition":"2024","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["swagger-ui"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libpoem_openapi-93f891532c146b5c.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#strum@0.26.3","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strum-0.26.3/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"strum","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/strum-0.26.3/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","derive","std","strum_macros"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libstrum-1ed14d88f79b8044.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#sqlx@0.8.6","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-0.8.6/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"sqlx","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/sqlx-0.8.6/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["_rt-tokio","_sqlite","any","chrono","default","derive","json","macros","migrate","postgres","runtime-tokio","runtime-tokio-rustls","sqlite","sqlx-macros","sqlx-postgres","sqlx-sqlite","tls-rustls-ring","tls-rustls-ring-webpki"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libsqlx-ea8b4f9e693dc42e.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#tracing-subscriber@0.3.20","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-subscriber-0.3.20/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"tracing_subscriber","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/tracing-subscriber-0.3.20/src/lib.rs","edition":"2018","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["alloc","ansi","default","env-filter","fmt","matchers","nu-ansi-term","once_cell","registry","sharded-slab","smallvec","std","thread_local","tracing","tracing-log"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtracing_subscriber-d12d9807acd383f3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#validator@0.18.1","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/validator-0.18.1/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"validator","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/validator-0.18.1/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["derive","validator_derive"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libvalidator-ef022f29e937a1a7.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#toml@0.8.23","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml-0.8.23/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"toml","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/toml-0.8.23/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default","display","parse"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libtoml-a75d64f3905058d3.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-artifact","package_id":"registry+https://github.com/rust-lang/crates.io-index#reqwest@0.11.27","manifest_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/reqwest-0.11.27/Cargo.toml","target":{"kind":["lib"],"crate_types":["lib"],"name":"reqwest","src_path":"/home/zanewalker/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/reqwest-0.11.27/src/lib.rs","edition":"2021","doc":true,"doctest":true,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["__rustls","__tls","hyper-rustls","json","mime_guess","multipart","rustls","rustls-tls","rustls-tls-webpki-roots","serde_json","tokio-rustls","webpki-roots"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libreqwest-a217578c55cd48bf.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"unused import: `anyhow`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/database.rs","byte_start":21,"byte_end":27,"line_start":1,"line_end":1,"column_start":22,"column_end":28,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":22,"highlight_end":28}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the unused import","code":null,"level":"help","spans":[{"file_name":"src/database.rs","byte_start":19,"byte_end":27,"line_start":1,"line_end":1,"column_start":20,"column_end":28,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":20,"highlight_end":28}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null},{"file_name":"src/database.rs","byte_start":12,"byte_end":13,"line_start":1,"line_end":1,"column_start":13,"column_end":14,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":13,"highlight_end":14}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null},{"file_name":"src/database.rs","byte_start":27,"byte_end":28,"line_start":1,"line_end":1,"column_start":28,"column_end":29,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":28,"highlight_end":29}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: unused import: `anyhow`\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/database.rs:1:22\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m1\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0muse anyhow::{Result, anyhow};\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                      \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(unused_imports)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"unused variable: `start_time`","code":{"code":"unused_variables","explanation":null},"level":"warning","spans":[{"file_name":"src/v1/routes/health.rs","byte_start":1373,"byte_end":1383,"line_start":47,"line_end":47,"column_start":13,"column_end":23,"is_primary":true,"text":[{"text":"        let start_time = std::time::Instant::now();","highlight_start":13,"highlight_end":23}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_variables)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"if this is intentional, prefix it with an underscore","code":null,"level":"help","spans":[{"file_name":"src/v1/routes/health.rs","byte_start":1373,"byte_end":1383,"line_start":47,"line_end":47,"column_start":13,"column_end":23,"is_primary":true,"text":[{"text":"        let start_time = std::time::Instant::now();","highlight_start":13,"highlight_end":23}],"label":null,"suggested_replacement":"_start_time","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: unused variable: `start_time`\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/v1/routes/health.rs:47:13\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m47\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m        let start_time = std::time::Instant::now();\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m             \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[33mhelp: if this is intentional, prefix it with an underscore: `_start_time`\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(unused_variables)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"methods `list_ollama_models`, `get_anthropic_models`, and `list_lmstudio_models` are never used","code":{"code":"dead_code","explanation":null},"level":"warning","spans":[{"file_name":"src/llm.rs","byte_start":2016,"byte_end":2030,"line_start":89,"line_end":89,"column_start":1,"column_end":15,"is_primary":false,"text":[{"text":"impl LlmClient {","highlight_start":1,"highlight_end":15}],"label":"methods in this implementation","suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":7463,"byte_end":7481,"line_start":228,"line_end":228,"column_start":18,"column_end":36,"is_primary":true,"text":[{"text":"    pub async fn list_ollama_models(&self) -> Result<Vec<_OllamaModelInfo>> {","highlight_start":18,"highlight_end":36}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":8041,"byte_end":8061,"line_start":245,"line_end":245,"column_start":12,"column_end":32,"is_primary":true,"text":[{"text":"    pub fn get_anthropic_models(&self) -> Vec<String> {","highlight_start":12,"highlight_end":32}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":11901,"byte_end":11921,"line_start":364,"line_end":364,"column_start":18,"column_end":38,"is_primary":true,"text":[{"text":"    pub async fn list_lmstudio_models(&self) -> Result<Vec<_OllamaModelInfo>> {","highlight_start":18,"highlight_end":38}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(dead_code)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: methods `list_ollama_models`, `get_anthropic_models`, and `list_lmstudio_models` are never used\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/llm.rs:228:18\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m89\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mimpl LlmClient {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--------------\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12mmethods in this implementation\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m228\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn list_ollama_models(&self) -> Result<Vec<_OllamaModelInfo>> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m245\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub fn get_anthropic_models(&self) -> Vec<String> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m            \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m364\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn list_lmstudio_models(&self) -> Result<Vec<_OllamaModelInfo>> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(dead_code)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"method `check_rate_limit` is never used","code":{"code":"dead_code","explanation":null},"level":"warning","spans":[{"file_name":"src/database.rs","byte_start":303,"byte_end":316,"line_start":16,"line_end":16,"column_start":1,"column_end":14,"is_primary":false,"text":[{"text":"impl Database {","highlight_start":1,"highlight_end":14}],"label":"method in this implementation","suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/database.rs","byte_start":24371,"byte_end":24387,"line_start":661,"line_end":661,"column_start":18,"column_end":34,"is_primary":true,"text":[{"text":"    pub async fn check_rate_limit(&self, guild_id: &str, user_id: &str, guild_limit: u32, user_limit: u32) -> Result<(bool, bool)> {","highlight_start":18,"highlight_end":34}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: method `check_rate_limit` is never used\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/database.rs:661:18\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m16\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mimpl Database {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m-------------\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12mmethod in this implementation\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m661\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn check_rate_limit(&self, guild_id: &str, user_id: &str, guild_limit: u32, user_limit: u32) -> Result<(bool, bool)> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^\u001b[0m\n\n"}}
+{"reason":"compiler-artifact","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":false},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbackend_api-9190cba8cf1dc326.rmeta"],"executable":null,"fresh":true}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"unused import: `anyhow`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/database.rs","byte_start":21,"byte_end":27,"line_start":1,"line_end":1,"column_start":22,"column_end":28,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":22,"highlight_end":28}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the unused import","code":null,"level":"help","spans":[{"file_name":"src/database.rs","byte_start":19,"byte_end":27,"line_start":1,"line_end":1,"column_start":20,"column_end":28,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":20,"highlight_end":28}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null},{"file_name":"src/database.rs","byte_start":12,"byte_end":13,"line_start":1,"line_end":1,"column_start":13,"column_end":14,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":13,"highlight_end":14}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null},{"file_name":"src/database.rs","byte_start":27,"byte_end":28,"line_start":1,"line_end":1,"column_start":28,"column_end":29,"is_primary":true,"text":[{"text":"use anyhow::{Result, anyhow};","highlight_start":28,"highlight_end":29}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: unused import: `anyhow`\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/database.rs:1:22\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m1\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0muse anyhow::{Result, anyhow};\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                      \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(unused_imports)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"unused variable: `start_time`","code":{"code":"unused_variables","explanation":null},"level":"warning","spans":[{"file_name":"src/v1/routes/health.rs","byte_start":1373,"byte_end":1383,"line_start":47,"line_end":47,"column_start":13,"column_end":23,"is_primary":true,"text":[{"text":"        let start_time = std::time::Instant::now();","highlight_start":13,"highlight_end":23}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_variables)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"if this is intentional, prefix it with an underscore","code":null,"level":"help","spans":[{"file_name":"src/v1/routes/health.rs","byte_start":1373,"byte_end":1383,"line_start":47,"line_end":47,"column_start":13,"column_end":23,"is_primary":true,"text":[{"text":"        let start_time = std::time::Instant::now();","highlight_start":13,"highlight_end":23}],"label":null,"suggested_replacement":"_start_time","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: unused variable: `start_time`\u001b[0m\n\u001b[0m  \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/v1/routes/health.rs:47:13\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m47\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m        let start_time = std::time::Instant::now();\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m             \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[33mhelp: if this is intentional, prefix it with an underscore: `_start_time`\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(unused_variables)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"methods `list_ollama_models`, `get_anthropic_models`, and `list_lmstudio_models` are never used","code":{"code":"dead_code","explanation":null},"level":"warning","spans":[{"file_name":"src/llm.rs","byte_start":2016,"byte_end":2030,"line_start":89,"line_end":89,"column_start":1,"column_end":15,"is_primary":false,"text":[{"text":"impl LlmClient {","highlight_start":1,"highlight_end":15}],"label":"methods in this implementation","suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":7463,"byte_end":7481,"line_start":228,"line_end":228,"column_start":18,"column_end":36,"is_primary":true,"text":[{"text":"    pub async fn list_ollama_models(&self) -> Result<Vec<_OllamaModelInfo>> {","highlight_start":18,"highlight_end":36}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":8041,"byte_end":8061,"line_start":245,"line_end":245,"column_start":12,"column_end":32,"is_primary":true,"text":[{"text":"    pub fn get_anthropic_models(&self) -> Vec<String> {","highlight_start":12,"highlight_end":32}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/llm.rs","byte_start":11901,"byte_end":11921,"line_start":364,"line_end":364,"column_start":18,"column_end":38,"is_primary":true,"text":[{"text":"    pub async fn list_lmstudio_models(&self) -> Result<Vec<_OllamaModelInfo>> {","highlight_start":18,"highlight_end":38}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(dead_code)]` on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null}],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: methods `list_ollama_models`, `get_anthropic_models`, and `list_lmstudio_models` are never used\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/llm.rs:228:18\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m89\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mimpl LlmClient {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--------------\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12mmethods in this implementation\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m228\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn list_ollama_models(&self) -> Result<Vec<_OllamaModelInfo>> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m245\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub fn get_anthropic_models(&self) -> Vec<String> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m            \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m364\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn list_lmstudio_models(&self) -> Result<Vec<_OllamaModelInfo>> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^^^^^\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m= \u001b[0m\u001b[0m\u001b[1mnote\u001b[0m\u001b[0m: `#[warn(dead_code)]` on by default\u001b[0m\n\n"}}
+{"reason":"compiler-message","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"message":{"$message_type":"diagnostic","message":"method `check_rate_limit` is never used","code":{"code":"dead_code","explanation":null},"level":"warning","spans":[{"file_name":"src/database.rs","byte_start":303,"byte_end":316,"line_start":16,"line_end":16,"column_start":1,"column_end":14,"is_primary":false,"text":[{"text":"impl Database {","highlight_start":1,"highlight_end":14}],"label":"method in this implementation","suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/database.rs","byte_start":24371,"byte_end":24387,"line_start":661,"line_end":661,"column_start":18,"column_end":34,"is_primary":true,"text":[{"text":"    pub async fn check_rate_limit(&self, guild_id: &str, user_id: &str, guild_limit: u32, user_limit: u32) -> Result<(bool, bool)> {","highlight_start":18,"highlight_end":34}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[],"rendered":"\u001b[0m\u001b[1m\u001b[33mwarning\u001b[0m\u001b[0m\u001b[1m: method `check_rate_limit` is never used\u001b[0m\n\u001b[0m   \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m--> \u001b[0m\u001b[0msrc/database.rs:661:18\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\n\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m16\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0mimpl Database {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m-------------\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12mmethod in this implementation\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m...\u001b[0m\n\u001b[0m\u001b[1m\u001b[38;5;12m661\u001b[0m\u001b[0m \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m \u001b[0m\u001b[0m    pub async fn check_rate_limit(&self, guild_id: &str, user_id: &str, guild_limit: u32, user_limit: u32) -> Result<(bool, bool)> {\u001b[0m\n\u001b[0m    \u001b[0m\u001b[0m\u001b[1m\u001b[38;5;12m|\u001b[0m\u001b[0m                  \u001b[0m\u001b[0m\u001b[1m\u001b[33m^^^^^^^^^^^^^^^^\u001b[0m\n\n"}}
+{"reason":"compiler-artifact","package_id":"path+file:///home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api#0.1.0","manifest_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/Cargo.toml","target":{"kind":["bin"],"crate_types":["bin"],"name":"backend_api","src_path":"/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/src/main.rs","edition":"2021","doc":true,"doctest":false,"test":true},"profile":{"opt_level":"0","debuginfo":2,"debug_assertions":true,"overflow_checks":true,"test":true},"features":["default"],"filenames":["/home/zanewalker/Development/Programming/PythonProjects/DiscordBots/Summarizer_Bot/backend_api/target/debug/deps/libbackend_api-481a5c4969a266a8.rmeta"],"executable":null,"fresh":true}
+{"reason":"build-finished","success":true}