Buckets:
AnonymousSpottedToad/candidate_bucket / codebase /python /CIRISAI_CIRISAgent /ciris_sdk /telemetry_models.py
| """ | |
| Telemetry-specific models for CIRIS SDK. | |
| These models provide type-safe alternatives to Dict[str, Any] usage | |
| in telemetry operations. | |
| """ | |
| from __future__ import annotations | |
| from datetime import datetime | |
| from typing import Any, Dict, List, Optional, Union | |
| from pydantic import BaseModel, ConfigDict, Field, field_serializer | |
| # Resource Models | |
| class ResourceUsage(BaseModel): | |
| """Current resource usage metrics.""" | |
| cpu_percent: float = Field(..., description="CPU usage percentage") | |
| memory_mb: float = Field(..., description="Memory usage in MB") | |
| memory_percent: float = Field(..., description="Memory usage percentage") | |
| disk_gb: Optional[float] = Field(None, description="Disk usage in GB") | |
| disk_percent: Optional[float] = Field(None, description="Disk usage percentage") | |
| network_connections: Optional[int] = Field(None, description="Active network connections") | |
| open_files: Optional[int] = Field(None, description="Open file descriptors") | |
| threads: Optional[int] = Field(None, description="Active threads") | |
| model_config = ConfigDict(extra="allow") | |
| class ResourceLimits(BaseModel): | |
| """Resource limits configuration.""" | |
| max_memory_mb: Optional[float] = Field(None, description="Maximum memory in MB") | |
| max_cpu_percent: Optional[float] = Field(None, description="Maximum CPU percentage") | |
| max_disk_gb: Optional[float] = Field(None, description="Maximum disk in GB") | |
| max_connections: Optional[int] = Field(None, description="Maximum network connections") | |
| max_open_files: Optional[int] = Field(None, description="Maximum open files") | |
| model_config = ConfigDict(extra="allow") | |
| class ResourceHealth(BaseModel): | |
| """Resource health status.""" | |
| status: str = Field(..., description="Overall health status: healthy|degraded|critical") | |
| warnings: List[str] = Field(default_factory=list, description="Health warnings") | |
| # Optional fields for backward compatibility | |
| cpu_health: Optional[str] = Field(None, description="CPU health status") | |
| memory_health: Optional[str] = Field(None, description="Memory health status") | |
| disk_health: Optional[str] = Field(None, description="Disk health status") | |
| model_config = ConfigDict(extra="allow") | |
| class ResourceHistoryPoint(BaseModel): | |
| """Single point in resource history.""" | |
| timestamp: datetime = Field(..., description="Measurement timestamp") | |
| value: float = Field(..., description="Measured value") | |
| unit: Optional[str] = Field(None, description="Unit of measurement") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| # Metric Models | |
| class MetricData(BaseModel): | |
| """Individual metric data.""" | |
| name: str = Field(..., description="Metric name") | |
| value: float = Field(..., description="Current value") | |
| unit: Optional[str] = Field(None, description="Unit of measurement") | |
| timestamp: datetime = Field(..., description="Measurement time") | |
| tags: Dict[str, str] = Field(default_factory=dict, description="Metric tags") | |
| service: Optional[str] = Field(None, description="Service that produced metric") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| class MetricAggregate(BaseModel): | |
| """Aggregated metric statistics.""" | |
| min: float = Field(..., description="Minimum value") | |
| max: float = Field(..., description="Maximum value") | |
| avg: float = Field(..., description="Average value") | |
| sum: float = Field(..., description="Sum of values") | |
| count: int = Field(..., description="Number of data points") | |
| p50: Optional[float] = Field(None, description="50th percentile") | |
| p95: Optional[float] = Field(None, description="95th percentile") | |
| p99: Optional[float] = Field(None, description="99th percentile") | |
| class MetricTrend(BaseModel): | |
| """Metric trend information.""" | |
| direction: str = Field(..., description="Trend direction: up|down|stable") | |
| change_percent: float = Field(..., description="Percentage change") | |
| change_absolute: float = Field(..., description="Absolute change") | |
| period: str = Field(..., description="Period of comparison") | |
| # Query Models | |
| class QueryFilter(BaseModel): | |
| """Filter for telemetry queries.""" | |
| field: str = Field(..., description="Field to filter on") | |
| operator: str = Field(..., description="Comparison operator: eq|ne|gt|lt|gte|lte|contains|in") | |
| value: Union[str, int, float, bool, List[Union[str, int, float]]] = Field(..., description="Filter value") | |
| model_config = ConfigDict(extra="forbid") | |
| class QueryFilters(BaseModel): | |
| """Collection of query filters.""" | |
| filters: List[QueryFilter] = Field(default_factory=list, description="List of filters") | |
| logic: str = Field(default="AND", description="Filter logic: AND|OR") | |
| model_config = ConfigDict(extra="forbid") | |
| # Thought Models for Traces | |
| class ThoughtData(BaseModel): | |
| """Thought information in traces.""" | |
| thought_id: str = Field(..., description="Unique thought ID") | |
| content: str = Field(..., description="Thought content") | |
| handler: str = Field(..., description="Handler that processed thought") | |
| created_at: datetime = Field(..., description="Creation time") | |
| completed_at: Optional[datetime] = Field(None, description="Completion time") | |
| status: str = Field(..., description="Status: PENDING|PROCESSING|COMPLETED|FAILED") | |
| result: Optional[str] = Field(None, description="Processing result") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| # Lineage Models | |
| class LineageInfo(BaseModel): | |
| """Agent lineage information.""" | |
| version: str = Field(..., description="Agent version") | |
| commit: Optional[str] = Field(None, description="Git commit hash") | |
| build_date: Optional[datetime] = Field(None, description="Build date") | |
| parent_version: Optional[str] = Field(None, description="Parent version") | |
| environment: Optional[str] = Field(None, description="Deployment environment") | |
| model_config = ConfigDict(extra="allow") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| # Processor State Models | |
| class ProcessorStateData(BaseModel): | |
| """Processor state information.""" | |
| is_running: bool = Field(..., description="Whether processor is running") | |
| current_state: str = Field(..., description="Current cognitive state") | |
| current_round: int = Field(..., description="Current processing round") | |
| thoughts_pending: int = Field(..., description="Pending thoughts") | |
| thoughts_processing: int = Field(..., description="Currently processing thoughts") | |
| last_activity: Optional[datetime] = Field(None, description="Last activity time") | |
| idle_rounds: int = Field(..., description="Consecutive idle rounds") | |
| model_config = ConfigDict(extra="allow") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| # Configuration Models | |
| class ConfigurationData(BaseModel): | |
| """System configuration snapshot.""" | |
| profile: str = Field(..., description="Active configuration profile") | |
| environment: str = Field(..., description="Deployment environment") | |
| debug_mode: bool = Field(..., description="Debug mode enabled") | |
| log_level: str = Field(..., description="Logging level") | |
| features: Dict[str, bool] = Field(default_factory=dict, description="Feature flags") | |
| model_config = ConfigDict(extra="allow") | |
| # Service Metadata Models | |
| class ServiceMetadata(BaseModel): | |
| """Service metadata information.""" | |
| version: Optional[str] = Field(None, description="Service version") | |
| uptime_seconds: Optional[float] = Field(None, description="Service uptime") | |
| last_restart: Optional[datetime] = Field(None, description="Last restart time") | |
| restart_count: Optional[int] = Field(None, description="Number of restarts") | |
| error_count: Optional[int] = Field(None, description="Error count") | |
| model_config = ConfigDict(extra="allow") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
| # Context Models | |
| class InteractionContext(BaseModel): | |
| """Context for agent interactions.""" | |
| channel_id: Optional[str] = Field(None, description="Channel identifier") | |
| user_id: Optional[str] = Field(None, description="User identifier") | |
| session_id: Optional[str] = Field(None, description="Session identifier") | |
| metadata: Dict[str, str] = Field(default_factory=dict, description="Additional metadata") | |
| model_config = ConfigDict(extra="allow") | |
| class AuditContext(BaseModel): | |
| """Context for audit entries.""" | |
| ip_address: Optional[str] = Field(None, description="Client IP address") | |
| user_agent: Optional[str] = Field(None, description="User agent string") | |
| request_id: Optional[str] = Field(None, description="Request identifier") | |
| session_id: Optional[str] = Field(None, description="Session identifier") | |
| metadata: Dict[str, str] = Field(default_factory=dict, description="Additional metadata") | |
| model_config = ConfigDict(extra="allow") | |
| class DeferralContext(BaseModel): | |
| """Context for deferrals.""" | |
| original_thought_id: str = Field(..., description="Original thought ID") | |
| authority_id: str = Field(..., description="Authority that created deferral") | |
| priority: str = Field(..., description="Deferral priority") | |
| metadata: Dict[str, str] = Field(default_factory=dict, description="Additional metadata") | |
| model_config = ConfigDict(extra="allow") | |
| # Verification Models | |
| class VerificationResult(BaseModel): | |
| """Result of verification operations.""" | |
| is_valid: bool = Field(..., description="Whether verification passed") | |
| verified_at: datetime = Field(..., description="Verification timestamp") | |
| method: str = Field(..., description="Verification method used") | |
| details: Dict[str, str] = Field(default_factory=dict, description="Verification details") | |
| def serialize_datetime(self, dt: Optional[datetime], _info: Any) -> Optional[str]: | |
| return dt.isoformat() if dt else None | |
Xet Storage Details
- Size:
- 10.6 kB
- Xet hash:
- 9ec887cd82b4acfc5534752099da4be90193787acf86931c9e16e23190e50ad7
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.