Add utc

Author: Maciek-roboblog

CHANGELOG.md

@@ -2,6 +2,27 @@
 
 ## [2.0.0] - 2025-06-25
 
+### Added (Post-release update - 2025-06-26)
+- **🌐 Enhanced UTC-First Timezone Architecture**: Robust timezone handling improvements
+  - New `timezone_utils.py` module with comprehensive timezone utilities
+  - Robust timestamp parsing supporting multiple formats (ISO, Unix timestamps, timezone-naive)
+  - Timezone validation pipeline with caching for performance
+  - Automatic zoneinfo support for Python 3.9+ with pytz fallback
+  - Cross-platform timezone detection (Windows, macOS, Linux)
+  - Improved error handling and logging throughout timezone operations
+- **🔧 Modern Python Compatibility**: Future-proof timezone handling
+  - Conditional import of zoneinfo (Python 3.9+) or pytz (Python 3.8)
+  - Windows timezone data support via tzdata package
+  - Backwards compatibility maintained for all Python versions ≥3.8
+
+### Changed (Post-release update - 2025-06-26)
+- Enhanced `data_loader.py` with robust timestamp parsing using TimezoneHandler
+- Improved `json_formatter.py` timezone handling to maintain timezone awareness
+- Updated `claude_monitor.py` with better timezone error handling and validation
+- Added `tzdata` dependency for Windows systems to support zoneinfo
+
+## [2.0.0] - 2025-06-25
+
 ### Added
 - **🎨 Smart Theme System**: Automatic light/dark theme detection for optimal terminal appearance
   - Intelligent theme detection based on terminal environment, system settings, and background color

claude_monitor.py

@@ -6,11 +6,13 @@
 import sys
 import threading
 from datetime import datetime, timedelta
+import logging
 
 import pytz
 
 from usage_analyzer.api import analyze_usage
 from usage_analyzer.themes import get_themed_console, print_themed, ThemeType
+from usage_analyzer.utils.timezone_utils import TimezoneHandler, safe_timezone_conversion
 
 # All internal calculations use UTC, display timezone is configurable
 UTC_TZ = pytz.UTC
@@ -154,13 +156,14 @@ def calculate_hourly_burn_rate(blocks, current_time):
         if not start_time_str:
             continue
 
-        # Parse start time - data from usage_analyzer is in UTC
-        start_time = datetime.fromisoformat(start_time_str.replace("Z", "+00:00"))
-        # Ensure it's in UTC for calculations
-        if start_time.tzinfo is None:
-            start_time = UTC_TZ.localize(start_time)
-        else:
-            start_time = start_time.astimezone(UTC_TZ)
+        # Parse start time using robust timestamp parsing
+        tz_handler = TimezoneHandler()
+        try:
+            start_time = tz_handler.parse_timestamp(start_time_str)
+            start_time = tz_handler.ensure_utc(start_time)
+        except Exception as e:
+            logging.debug(f"Failed to parse start time '{start_time_str}': {e}")
+            continue
 
         # Skip gaps
         if block.get("isGap", False):
@@ -174,14 +177,12 @@ def calculate_hourly_burn_rate(blocks, current_time):
             # For completed sessions, use actualEndTime or current time
             actual_end_str = block.get("actualEndTime")
             if actual_end_str:
-                session_actual_end = datetime.fromisoformat(
-                    actual_end_str.replace("Z", "+00:00")
-                )
-                # Ensure it's in UTC for calculations
-                if session_actual_end.tzinfo is None:
-                    session_actual_end = UTC_TZ.localize(session_actual_end)
-                else:
-                    session_actual_end = session_actual_end.astimezone(UTC_TZ)
+                try:
+                    session_actual_end = tz_handler.parse_timestamp(actual_end_str)
+                    session_actual_end = tz_handler.ensure_utc(session_actual_end)
+                except Exception as e:
+                    logging.debug(f"Failed to parse actual end time '{actual_end_str}': {e}")
+                    session_actual_end = current_time
             else:
                 session_actual_end = current_time
 
@@ -530,12 +531,15 @@ def main():
             screen_buffer.append("")
 
             # Predictions - convert to configured timezone for display
-            try:
-                local_tz = pytz.timezone(args.timezone)
-            except pytz.exceptions.UnknownTimeZoneError:
-                local_tz = pytz.timezone("Europe/Warsaw")
-            predicted_end_local = predicted_end_time.astimezone(local_tz)
-            reset_time_local = reset_time.astimezone(local_tz)
+            tz_handler = TimezoneHandler(default_tz="Europe/Warsaw")
+            if not tz_handler.validate_timezone(args.timezone):
+                print_themed(f"Invalid timezone '{args.timezone}', using Europe/Warsaw", style="warning")
+                timezone_to_use = "Europe/Warsaw"
+            else:
+                timezone_to_use = args.timezone
+            
+            predicted_end_local = tz_handler.convert_to_timezone(predicted_end_time, timezone_to_use)
+            reset_time_local = tz_handler.convert_to_timezone(reset_time, timezone_to_use)
 
             predicted_end_str = predicted_end_local.strftime("%H:%M")
             reset_time_str = reset_time_local.strftime("%H:%M")

pyproject.toml

@@ -35,6 +35,7 @@ classifiers = [
 dependencies = [
     "pytz",
     "rich>=13.0.0",
+    "tzdata; sys_platform == 'win32'",  # Required for zoneinfo on Windows
 ]
 
 [project.optional-dependencies]

usage_analyzer/core/data_loader.py

@@ -8,9 +8,11 @@
 from pathlib import Path
 from typing import List, Optional
 import json
+import logging
 
 from usage_analyzer.utils.path_discovery import discover_claude_data_paths
 from usage_analyzer.utils.pricing_fetcher import ClaudePricingFetcher
+from usage_analyzer.utils.timezone_utils import TimezoneHandler
 from usage_analyzer.models.data_structures import UsageEntry, CostMode
 
 
@@ -27,6 +29,8 @@ def __init__(self, data_path: Optional[str] = None):
             self.data_path = Path(data_path).expanduser()
 
         self.pricing_fetcher = ClaudePricingFetcher()
+        self.timezone_handler = TimezoneHandler()
+        self.logger = logging.getLogger(__name__)
 
     def load_usage_data(self, mode: CostMode = CostMode.AUTO) -> List[UsageEntry]:
         """Load and process all usage data."""
@@ -142,7 +146,14 @@ def _convert_to_usage_entry(self, data: dict, mode: CostMode) -> Optional[UsageE
             if 'timestamp' not in data:
                 return None
 
-            timestamp = datetime.fromisoformat(data['timestamp'].replace('Z', '+00:00'))
+            # Use robust timestamp parsing with error handling
+            try:
+                timestamp = self.timezone_handler.parse_timestamp(data['timestamp'])
+                # Ensure timestamp is in UTC for internal processing
+                timestamp = self.timezone_handler.ensure_utc(timestamp)
+            except Exception as e:
+                self.logger.debug(f"Failed to parse timestamp '{data.get('timestamp')}': {e}")
+                return None
 
             # Handle both nested and flat usage data
             usage = data.get('usage', {})

usage_analyzer/output/json_formatter.py

@@ -7,10 +7,12 @@
 
 import json
 from typing import Any, Dict, List
+from datetime import datetime
 
 from usage_analyzer.models.data_structures import SessionBlock
 from usage_analyzer.core.calculator import BurnRateCalculator
 from usage_analyzer.utils.pricing_fetcher import ClaudePricingFetcher
+from usage_analyzer.utils.timezone_utils import TimezoneHandler
 from usage_analyzer.themes import print_themed, get_themed_console
 
 
@@ -21,6 +23,7 @@ def __init__(self):
         """Initialize formatter."""
         self.calculator = BurnRateCalculator()
         self.pricing_fetcher = ClaudePricingFetcher()
+        self.timezone_handler = TimezoneHandler()
 
     def print_summary(self, blocks: List[SessionBlock]) -> None:
         """Print a themed summary of session blocks."""
@@ -168,17 +171,18 @@ def _format_per_model_stats(self, per_model_stats: Dict[str, Dict[str, Any]], pe
 
         return formatted_stats
 
-    def _format_timestamp(self, timestamp) -> str:
+    def _format_timestamp(self, timestamp: datetime) -> str:
         """Format datetime to match format with milliseconds precision."""
         if timestamp is None:
             return None
-        # Convert to UTC if needed
-        if timestamp.tzinfo is not None:
-            from datetime import timezone
-            utc_timestamp = timestamp.astimezone(timezone.utc).replace(tzinfo=None)
-        else:
-            utc_timestamp = timestamp
+        
+        # Ensure timestamp is in UTC using our robust handler
+        utc_timestamp = self.timezone_handler.ensure_utc(timestamp)
 
         # Format with milliseconds precision (.XXXZ)
+        # Keep timezone information by formatting properly
         milliseconds = utc_timestamp.microsecond // 1000
-        return utc_timestamp.strftime(f'%Y-%m-%dT%H:%M:%S.{milliseconds:03d}Z')
+        # Use ISO format with explicit UTC 'Z' suffix
+        formatted = utc_timestamp.strftime(f'%Y-%m-%dT%H:%M:%S.{milliseconds:03d}')
+        # Add 'Z' suffix to indicate UTC (maintaining timezone awareness)
+        return f"{formatted}Z"