mirror of
https://github.com/hanzoskill/oura-analytics.git
synced 2026-10-30 21:10:57 +00:00
277 lines
10 KiB
Python
277 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
"""
|
|
Oura Weekly Report Generator
|
|
|
|
Generates automated weekly health reports and can send to Telegram.
|
|
"""
|
|
|
|
import argparse
|
|
import os
|
|
import sys
|
|
import json
|
|
import urllib.request
|
|
import urllib.error
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
|
|
# Add scripts directory to path for imports
|
|
sys.path.insert(0, str(Path(__file__).resolve().parent))
|
|
|
|
from oura_api import OuraClient
|
|
|
|
|
|
def seconds_to_hours(seconds):
|
|
return round(seconds / 3600, 1) if seconds else None
|
|
|
|
|
|
def calculate_sleep_score(day):
|
|
efficiency = day.get("efficiency", 0)
|
|
duration_hours = seconds_to_hours(day.get("total_sleep_duration", 0)) or 0
|
|
eff_score = min(efficiency, 100)
|
|
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
|
|
|
|
Args:
|
|
sleep_data: List of sleep records from get_sleep()
|
|
readiness_data: List of readiness records from get_readiness() (optional for backwards compatibility)
|
|
"""
|
|
if not sleep_data:
|
|
return None
|
|
|
|
# Calculate scores - handle case where efficiency may not be in sleep endpoint
|
|
scores = []
|
|
for d in sleep_data:
|
|
score = calculate_sleep_score(d)
|
|
if score is None or score == 0:
|
|
# Calculate from duration only when efficiency missing
|
|
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 from sleep data (may be 0 if not in /sleep endpoint)
|
|
efficiencies = [d.get("efficiency", 0) for d in sleep_data]
|
|
avg_efficiency = round(sum(efficiencies) / len(efficiencies), 1) if efficiencies and any(efficiencies) else None
|
|
|
|
durations = [seconds_to_hours(d.get("total_sleep_duration", 0)) for d in sleep_data]
|
|
|
|
# Build readiness lookup by day from dedicated dataset
|
|
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)
|
|
else:
|
|
# Fallback: try nested readiness (old broken format, for backwards compat)
|
|
r = d.get("readiness", {})
|
|
if r and isinstance(r, dict) and r.get("score"):
|
|
readiness_scores.append(r["score"])
|
|
|
|
# Calculate trend (first half vs second half)
|
|
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)
|
|
else:
|
|
sleep_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)
|
|
else:
|
|
readiness_trend = 0
|
|
|
|
# Get last 2 days individual 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
|
|
})
|
|
|
|
return {
|
|
"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,
|
|
"avg_efficiency": avg_efficiency,
|
|
"avg_duration": round(sum(durations) / len(durations), 1) if durations else None,
|
|
"sleep_trend": sleep_trend,
|
|
"readiness_trend": readiness_trend,
|
|
"best_day": sleep_data[scores.index(max(scores))].get("day") if sleep_data and scores else None,
|
|
"worst_day": sleep_data[scores.index(min(scores))].get("day") if sleep_data and scores else None,
|
|
"days_tracked": len(sleep_data),
|
|
"last_2_days": last_2_days
|
|
}
|
|
|
|
|
|
def format_telegram_message(week_data, period):
|
|
"""Format report for Telegram"""
|
|
emoji = {
|
|
"sleep": "😴",
|
|
"readiness": "⚡",
|
|
"efficiency": "📊",
|
|
"duration": "⏰",
|
|
"best": "🏆",
|
|
"worst": "⚠️",
|
|
"trend_up": "↗️",
|
|
"trend_down": "↘️",
|
|
"trend_same": "➡️"
|
|
}
|
|
|
|
# Trend indicators
|
|
sleep_trend = week_data.get('sleep_trend', 0)
|
|
readiness_trend = week_data.get('readiness_trend', 0)
|
|
|
|
def trend_emoji(val):
|
|
if val > 1:
|
|
return emoji["trend_up"]
|
|
elif val < -1:
|
|
return emoji["trend_down"]
|
|
return emoji["trend_same"]
|
|
|
|
msg = f"📈 *Oura Weekly Report* ({period})\n\n"
|
|
|
|
# Averages with trends
|
|
msg += f"{emoji['sleep']} Sleep Score: *{week_data['avg_sleep_score']}*/100 {trend_emoji(sleep_trend)}"
|
|
if sleep_trend != 0:
|
|
msg += f" ({'+' if sleep_trend > 0 else ''}{sleep_trend})"
|
|
msg += "\n"
|
|
|
|
msg += f"{emoji['readiness']} Readiness: *{week_data['avg_readiness']}*/100 {trend_emoji(readiness_trend)}"
|
|
if readiness_trend != 0:
|
|
msg += f" ({'+' if readiness_trend > 0 else ''}{readiness_trend})"
|
|
msg += "\n"
|
|
|
|
msg += f"{emoji['efficiency']} Efficiency: *{week_data['avg_efficiency']}%*\n"
|
|
msg += f"{emoji['duration']} Avg Sleep: *{week_data['avg_duration']}h*\n"
|
|
|
|
# Last 2 days
|
|
last_2_days = week_data.get('last_2_days', [])
|
|
if last_2_days:
|
|
msg += "\n📅 *Last 2 Days:*\n"
|
|
for day_data in last_2_days:
|
|
day = day_data.get('day', '')
|
|
sleep = day_data.get('sleep_score', 'N/A')
|
|
ready = day_data.get('readiness', 'N/A')
|
|
hours = day_data.get('hours', 'N/A')
|
|
ready_str = f"{ready}/100" if ready is not None else "N/A"
|
|
msg += f" {day}: 😴{sleep} ⚡{ready_str} ⏰{hours}h\n"
|
|
|
|
msg += f"\n{emoji['best']} Best: {week_data['best_day']}\n"
|
|
msg += f"{emoji['worst']} Worst: {week_data['worst_day']}\n"
|
|
msg += f"\n_Tracked: {week_data['days_tracked']} days_"
|
|
|
|
return msg
|
|
|
|
|
|
def send_telegram(message, chat_id=None, bot_token=None):
|
|
"""Send report to Telegram using urllib"""
|
|
chat_id = chat_id or os.environ.get("TELEGRAM_CHAT_ID")
|
|
bot_token = bot_token or os.environ.get("TELEGRAM_BOT_TOKEN")
|
|
|
|
if not chat_id or not bot_token:
|
|
print("TELEGRAM_CHAT_ID or TELEGRAM_BOT_TOKEN not set")
|
|
return False
|
|
|
|
url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
|
|
# Keep chat_id as string to support both numeric IDs and @channel usernames
|
|
data = json.dumps({"chat_id": chat_id, "text": message, "parse_mode": "Markdown"}).encode("utf-8")
|
|
|
|
req = urllib.request.Request(url, data=data, headers={"Content-Type": "application/json"})
|
|
|
|
try:
|
|
with urllib.request.urlopen(req, timeout=10) as resp:
|
|
return resp.status == 200
|
|
except urllib.error.HTTPError:
|
|
return False
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description="Oura Weekly Report")
|
|
parser.add_argument("--days", type=int, default=7, help="Report period")
|
|
parser.add_argument("--telegram", action="store_true", help="Send to Telegram")
|
|
parser.add_argument("--token", help="Oura API token")
|
|
|
|
args = parser.parse_args()
|
|
|
|
end_date = datetime.now().strftime("%Y-%m-%d")
|
|
start_date = (datetime.now() - timedelta(days=args.days)).strftime("%Y-%m-%d")
|
|
period = f"{start_date} → {end_date}"
|
|
|
|
try:
|
|
client = OuraClient(args.token)
|
|
sleep = client.get_sleep(start_date, end_date)
|
|
readiness = client.get_readiness(start_date, end_date)
|
|
week_data = analyze_week(sleep, readiness)
|
|
|
|
if not week_data:
|
|
print("No data available")
|
|
sys.exit(1)
|
|
|
|
# Print nicely
|
|
print(f"\n📊 Oura Weekly Report ({period})")
|
|
sleep_trend = week_data.get('sleep_trend', 0)
|
|
readiness_trend = week_data.get('readiness_trend', 0)
|
|
|
|
def trend_symbol(v):
|
|
return "↗️" if v > 0 else ("↘️" if v < 0 else "➡️")
|
|
|
|
print(f" Sleep Score: {week_data['avg_sleep_score']} {trend_symbol(sleep_trend)} ({'+' if sleep_trend > 0 else ''}{sleep_trend})")
|
|
print(f" Readiness: {week_data['avg_readiness']} {trend_symbol(readiness_trend)} ({'+' if readiness_trend > 0 else ''}{readiness_trend})")
|
|
print(f" Efficiency: {week_data['avg_efficiency']}%")
|
|
print(f" Avg Duration: {week_data['avg_duration']}h")
|
|
|
|
# Last 2 days
|
|
last_2 = week_data.get('last_2_days', [])
|
|
if last_2:
|
|
print("\n 📅 Last 2 Days:")
|
|
for d in last_2:
|
|
ready = d.get('readiness')
|
|
print(f" {d['day']}: 😴{d['sleep_score']} ⚡{ready}/100 ⏰{d['hours']}h")
|
|
|
|
print(f"\n Best: {week_data['best_day']} | Worst: {week_data['worst_day']}")
|
|
print(f" Tracked: {week_data['days_tracked']} days")
|
|
|
|
# Send to Telegram
|
|
if args.telegram:
|
|
msg = format_telegram_message(week_data, period)
|
|
if send_telegram(msg):
|
|
print("\n✅ Sent to Telegram!")
|
|
else:
|
|
print("\n❌ Telegram failed")
|
|
|
|
# Save to file
|
|
output_dir = os.environ.get("OURA_OUTPUT_DIR", str(Path.home() / ".oura-analytics" / "reports"))
|
|
report_file = f"{output_dir}/oura_weekly_{end_date}.json"
|
|
os.makedirs(output_dir, exist_ok=True)
|
|
with open(report_file, "w") as f:
|
|
json.dump({"period": period, "summary": week_data, "raw": sleep}, f, indent=2)
|
|
print(f"\n💾 Saved to {report_file}")
|
|
|
|
except Exception as e:
|
|
print(f"Error: {e}")
|
|
sys.exit(1)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|