mirror of
https://github.com/hanzoskill/oura-analytics.git
synced 2026-10-30 21:10:57 +00:00
228 lines
8.9 KiB
Python
228 lines
8.9 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Oura Morning Briefing CLI
|
|
|
|
Generate concise, actionable daily briefings.
|
|
|
|
Usage:
|
|
python oura_briefing.py # Today's briefing
|
|
python oura_briefing.py --date 2026-01-20 # Specific date
|
|
python oura_briefing.py --verbose # Detailed briefing
|
|
python oura_briefing.py --format json # JSON output
|
|
python oura_briefing.py --format brief # 3-line brief
|
|
"""
|
|
|
|
import argparse
|
|
import sys
|
|
import json
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
|
|
# Add scripts dir to path for imports
|
|
sys.path.insert(0, str(Path(__file__).parent))
|
|
|
|
from oura_api import OuraClient
|
|
from schema import create_night_record
|
|
from briefing import BriefingFormatter, Baseline, format_brief_briefing, format_json_briefing, format_hybrid_briefing
|
|
|
|
|
|
def _seconds_to_hours(seconds):
|
|
"""Convert seconds to hours. Returns None only if seconds is None."""
|
|
return round(seconds / 3600, 1) if seconds is not None else None
|
|
|
|
|
|
def _calculate_sleep_score(day):
|
|
"""Calculate sleep score from day record. Guards against null efficiency."""
|
|
efficiency = day.get("efficiency") or 0 # Handle None/null values
|
|
duration_hours = _seconds_to_hours(day.get("total_sleep_duration", 0)) or 0
|
|
eff_score = min(efficiency, 100) if efficiency else 0
|
|
dur_score = min(duration_hours / 8 * 100, 100)
|
|
return round((eff_score * 0.6) + (dur_score * 0.4), 1)
|
|
|
|
|
|
def _analyze_week(sleep_data, readiness_data=None):
|
|
"""Analyze weekly data for hybrid briefing."""
|
|
if not sleep_data:
|
|
return None
|
|
|
|
# Calculate sleep scores
|
|
scores = []
|
|
for d in sleep_data:
|
|
score = _calculate_sleep_score(d)
|
|
if score is None or score == 0:
|
|
duration_sec = d.get("total_sleep_duration", 0)
|
|
duration_hours = duration_sec / 3600 if duration_sec else 0
|
|
dur_score = min(duration_hours / 8 * 100, 100)
|
|
score = round(dur_score, 1)
|
|
scores.append(score)
|
|
|
|
# Get efficiency (handle None/null values)
|
|
efficiencies = [d.get("efficiency") or 0 for d in sleep_data]
|
|
avg_efficiency = round(sum(efficiencies) / len(efficiencies), 1) if efficiencies else None
|
|
|
|
# Get durations
|
|
durations = [_seconds_to_hours(d.get("total_sleep_duration", 0)) for d in sleep_data]
|
|
|
|
# Build readiness lookup by day
|
|
readiness_by_day = {}
|
|
if readiness_data:
|
|
readiness_by_day = {r.get("day"): r for r in readiness_data}
|
|
|
|
readiness_scores = []
|
|
for d in sleep_data:
|
|
day = d.get("day")
|
|
if day in readiness_by_day:
|
|
r = readiness_by_day[day].get("score")
|
|
if r:
|
|
readiness_scores.append(r)
|
|
|
|
# Calculate trends (first half vs second half)
|
|
sleep_trend = 0
|
|
if len(scores) >= 2:
|
|
half = len(scores) // 2
|
|
if half >= 1:
|
|
first_half_avg = sum(scores[:half]) / half
|
|
second_half_avg = sum(scores[half:]) / (len(scores) - half)
|
|
sleep_trend = round(second_half_avg - first_half_avg, 1)
|
|
|
|
readiness_trend = 0
|
|
if len(readiness_scores) >= 2:
|
|
half = len(readiness_scores) // 2
|
|
first_half_avg = sum(readiness_scores[:half]) / half
|
|
second_half_avg = sum(readiness_scores[half:]) / (len(readiness_scores) - half)
|
|
readiness_trend = round(second_half_avg - first_half_avg, 1)
|
|
|
|
# Get last 2 days data
|
|
last_2_days = []
|
|
for i, d in enumerate(sleep_data[-2:]):
|
|
day = d.get("day")
|
|
score = scores[-(2-i)] if len(scores) >= 2-i else scores[0]
|
|
hours = _seconds_to_hours(d.get("total_sleep_duration", 0))
|
|
r_score = readiness_by_day.get(day, {}).get("score") if day in readiness_by_day else None
|
|
last_2_days.append({
|
|
"day": day,
|
|
"sleep_score": score,
|
|
"readiness": r_score,
|
|
"hours": hours
|
|
})
|
|
|
|
# Calculate averages (filter None values from durations)
|
|
avg_sleep_score = round(sum(scores) / len(scores), 1) if scores else None
|
|
avg_readiness = round(sum(readiness_scores) / len(readiness_scores), 1) if readiness_scores else None
|
|
valid_durations = [d for d in durations if d is not None]
|
|
avg_duration = round(sum(valid_durations) / len(valid_durations), 1) if valid_durations else None
|
|
|
|
# Get HRV from most recent record (with data)
|
|
hrv = None
|
|
for d in reversed(sleep_data):
|
|
if d.get("average_hrv"):
|
|
hrv = d.get("average_hrv")
|
|
break
|
|
|
|
return {
|
|
"avg_sleep_score": avg_sleep_score,
|
|
"avg_readiness": avg_readiness,
|
|
"avg_efficiency": avg_efficiency,
|
|
"avg_duration": avg_duration,
|
|
"avg_hrv": hrv,
|
|
"sleep_trend": sleep_trend,
|
|
"readiness_trend": readiness_trend,
|
|
"last_2_days": last_2_days
|
|
}
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Oura Morning Briefing")
|
|
parser.add_argument("--date", help="Date for briefing (YYYY-MM-DD, default: today)")
|
|
parser.add_argument("--token", help="Oura API token")
|
|
parser.add_argument("--verbose", action="store_true", help="Detailed briefing with driver analysis")
|
|
parser.add_argument("--format", choices=["text", "brief", "json", "hybrid"], default="text",
|
|
help="Output format (text=full briefing, brief=3 lines, json=structured, hybrid=briefing+trends)")
|
|
parser.add_argument("--baseline-days", type=int, default=14,
|
|
help="Days to use for baseline calculation (default: 14)")
|
|
|
|
args = parser.parse_args()
|
|
|
|
try:
|
|
# Initialize client
|
|
client = OuraClient(args.token)
|
|
|
|
# Determine date
|
|
if args.date:
|
|
target_date = args.date
|
|
else:
|
|
target_date = datetime.now().strftime("%Y-%m-%d")
|
|
|
|
# Get data for target date
|
|
sleep_data = client.get_sleep(target_date, target_date)
|
|
readiness_data = client.get_readiness(target_date, target_date)
|
|
activity_data = client.get_activity(target_date, target_date)
|
|
|
|
# Bounds check: ensure arrays are not empty before accessing
|
|
if not sleep_data and not readiness_data:
|
|
print(f"No data available for {target_date}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
# Create night record (safe access with bounds check)
|
|
night = create_night_record(
|
|
date=target_date,
|
|
sleep=sleep_data[0] if (sleep_data and len(sleep_data) > 0) else None,
|
|
readiness=readiness_data[0] if (readiness_data and len(readiness_data) > 0) else None,
|
|
activity=activity_data[0] if (activity_data and len(activity_data) > 0) else None
|
|
)
|
|
|
|
# Calculate baseline from historical data
|
|
baseline_start = (datetime.strptime(target_date, "%Y-%m-%d") - timedelta(days=args.baseline_days)).strftime("%Y-%m-%d")
|
|
baseline_end = (datetime.strptime(target_date, "%Y-%m-%d") - timedelta(days=1)).strftime("%Y-%m-%d")
|
|
|
|
baseline_sleep = client.get_sleep(baseline_start, baseline_end)
|
|
baseline_readiness = client.get_readiness(baseline_start, baseline_end)
|
|
|
|
# Create baseline nights for calculation (align by date, not index)
|
|
baseline_nights = []
|
|
readiness_by_date = {r["day"]: r for r in baseline_readiness}
|
|
|
|
for sleep_entry in baseline_sleep:
|
|
date = sleep_entry["day"]
|
|
readiness_entry = readiness_by_date.get(date)
|
|
|
|
baseline_night = create_night_record(
|
|
date=date,
|
|
sleep=sleep_entry,
|
|
readiness=readiness_entry
|
|
)
|
|
baseline_nights.append(baseline_night)
|
|
|
|
baseline = Baseline.from_history(baseline_nights) if baseline_nights else None
|
|
|
|
# Fetch week data for hybrid format (7-day window: target_date - 6 through target_date)
|
|
week_data = None
|
|
if args.format == "hybrid":
|
|
week_start = (datetime.strptime(target_date, "%Y-%m-%d") - timedelta(days=6)).strftime("%Y-%m-%d")
|
|
week_sleep = client.get_sleep(week_start, target_date)
|
|
week_readiness = client.get_readiness(week_start, target_date)
|
|
week_data = _analyze_week(week_sleep, week_readiness)
|
|
|
|
# Format output
|
|
if args.format == "json":
|
|
output = format_json_briefing(night, baseline)
|
|
print(json.dumps(output, indent=2))
|
|
elif args.format == "brief":
|
|
output = format_brief_briefing(night, baseline)
|
|
print(output)
|
|
elif args.format == "hybrid":
|
|
output = format_hybrid_briefing(night, baseline, week_data)
|
|
print(output)
|
|
else: # text
|
|
formatter = BriefingFormatter(baseline)
|
|
output = formatter.format(night, verbose=args.verbose)
|
|
print(output)
|
|
|
|
except Exception as e:
|
|
print(f"ERROR: {e}", file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|