279 lines
9.0 KiB
Python
279 lines
9.0 KiB
Python
"""Definition of showcase data to be used for presenting the app."""
|
|
|
|
from datetime import datetime, timedelta
|
|
import random
|
|
|
|
# User credentials
|
|
SHOWCASE_USERS = [
|
|
{
|
|
"username": "user",
|
|
"password": "demo123", # Will be hashed when inserted
|
|
},
|
|
{
|
|
"username": "user2",
|
|
"password": "demo123", # Will be hashed when inserted
|
|
},
|
|
]
|
|
|
|
# Shared child (14 days old)
|
|
CHILD_AGE_DAYS = 14
|
|
|
|
|
|
def get_child_data(reference_time: datetime) -> dict:
|
|
"""Get child data with birth time relative to reference time."""
|
|
birth_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
|
|
return {
|
|
"name": "Emma Rose",
|
|
"birth_time": birth_time,
|
|
"birth_weight": 3420, # grams (7.5 lbs)
|
|
}
|
|
|
|
|
|
def get_feeding_schedule(reference_time: datetime) -> list[dict]:
|
|
"""
|
|
Generate realistic feeding schedule for the last 14 days.
|
|
|
|
Newborns feed every 2-3 hours initially, gradually spacing out
|
|
to 3-4 hours.
|
|
"""
|
|
feedings: list[dict] = []
|
|
current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
|
|
end_time = reference_time
|
|
|
|
feeding_types = ["left_breast", "right_breast", "bottle"]
|
|
|
|
# Day-by-day feeding patterns
|
|
day_number = 0
|
|
while current_time < end_time:
|
|
age_in_days = day_number
|
|
|
|
# Newborns feed more frequently
|
|
if age_in_days < 3:
|
|
interval_hours = random.uniform(2, 2.5)
|
|
duration_minutes = random.randint(15, 25)
|
|
elif age_in_days < 7:
|
|
interval_hours = random.uniform(2.5, 3)
|
|
duration_minutes = random.randint(20, 30)
|
|
else:
|
|
interval_hours = random.uniform(3, 3.5)
|
|
duration_minutes = random.randint(20, 35)
|
|
|
|
# Alternate between breasts and occasional bottle
|
|
if random.random() < 0.2: # 20% bottle feeding
|
|
feeding_type = "bottle"
|
|
else:
|
|
# Alternate breasts
|
|
feeding_type = feeding_types[len(feedings) % 2]
|
|
|
|
start_time = current_time
|
|
end_time_feeding = start_time + timedelta(minutes=duration_minutes)
|
|
|
|
feedings.append(
|
|
{
|
|
"start_time": start_time,
|
|
"end_time": end_time_feeding,
|
|
"feeding_type": feeding_type,
|
|
}
|
|
)
|
|
|
|
current_time += timedelta(hours=interval_hours)
|
|
|
|
# Move to next day
|
|
prev_date = (current_time - timedelta(hours=interval_hours)).date()
|
|
if current_time.date() != prev_date:
|
|
day_number += 1
|
|
|
|
return feedings
|
|
|
|
|
|
def get_diaper_changes(reference_time: datetime) -> list[dict]:
|
|
"""
|
|
Generate realistic diaper changes for the last 14 days.
|
|
|
|
- First 2-3 days: Black/dark (meconium), minimal pee
|
|
- Days 3-5: Transition to yellow, more frequent
|
|
- Days 5+: Regular yellow stools, normal pee patterns
|
|
- 8-10 diaper changes per day initially, settling to 6-8
|
|
"""
|
|
diapers = []
|
|
current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
|
|
end_time = reference_time
|
|
|
|
day_number = 0
|
|
|
|
while current_time < end_time:
|
|
age_in_days = day_number
|
|
|
|
# Determine number of diaper changes per day based on age
|
|
if age_in_days < 3:
|
|
changes_per_day = random.randint(8, 10)
|
|
elif age_in_days < 7:
|
|
changes_per_day = random.randint(7, 9)
|
|
else:
|
|
changes_per_day = random.randint(6, 8)
|
|
|
|
# Distribute changes throughout the day
|
|
day_start = current_time.replace(hour=0, minute=0, second=0, microsecond=0)
|
|
day_end = day_start + timedelta(days=1)
|
|
|
|
for _ in range(changes_per_day):
|
|
# Random time during the day
|
|
random_seconds = random.randint(0, 86400)
|
|
change_time = day_start + timedelta(seconds=random_seconds)
|
|
|
|
if change_time >= end_time:
|
|
break
|
|
|
|
# Determine diaper contents
|
|
has_poop = random.random() < 0.4 # 40% have poop
|
|
# 90% have pee, or always if no poop
|
|
has_pee = random.random() < 0.9 or not has_poop
|
|
|
|
diaper = {
|
|
"time": change_time,
|
|
"has_poop": has_poop,
|
|
"has_pee": has_pee,
|
|
}
|
|
|
|
# Poop characteristics based on age
|
|
if has_poop:
|
|
if age_in_days < 2:
|
|
# Meconium phase
|
|
diaper["poop_color"] = "black"
|
|
diaper["poop_amount"] = "light"
|
|
elif age_in_days < 4:
|
|
# Transition phase
|
|
colors = ["black", "green", "yellow"]
|
|
diaper["poop_color"] = random.choice(colors)
|
|
amounts = ["light", "medium"]
|
|
diaper["poop_amount"] = random.choice(amounts)
|
|
else:
|
|
# Normal phase
|
|
colors = ["yellow", "yellow", "yellow", "green"]
|
|
diaper["poop_color"] = random.choice(colors)
|
|
# Amount increases with age
|
|
if age_in_days < 7:
|
|
amounts = ["light", "medium"]
|
|
diaper["poop_amount"] = random.choice(amounts)
|
|
else:
|
|
amounts = ["medium", "heavy"]
|
|
diaper["poop_amount"] = random.choice(amounts)
|
|
|
|
# Pee characteristics based on age
|
|
if has_pee:
|
|
if age_in_days < 2:
|
|
# Very light pee initially
|
|
diaper["pee_amount"] = "light"
|
|
diaper["pee_color"] = random.choice(["clear", "yellow"])
|
|
elif age_in_days < 5:
|
|
# Increasing output
|
|
diaper["pee_amount"] = random.choice(["light", "medium"])
|
|
diaper["pee_color"] = random.choice(["clear", "yellow"])
|
|
else:
|
|
# Normal output
|
|
if age_in_days < 10:
|
|
amounts = ["medium", "medium", "heavy"]
|
|
diaper["pee_amount"] = random.choice(amounts)
|
|
else:
|
|
amounts = ["medium", "heavy", "heavy"]
|
|
diaper["pee_amount"] = random.choice(amounts)
|
|
colors = ["clear", "yellow", "yellow"]
|
|
diaper["pee_color"] = random.choice(colors)
|
|
|
|
diapers.append(diaper)
|
|
|
|
day_number += 1
|
|
current_time = day_end
|
|
|
|
# Sort by time (type: ignore for mypy - we know time is datetime)
|
|
diapers.sort(
|
|
key=lambda x: x["time"] # type: ignore[arg-type,return-value]
|
|
)
|
|
return diapers
|
|
|
|
|
|
def get_sleep_sessions(reference_time: datetime) -> list[dict]:
|
|
"""
|
|
Generate realistic sleep patterns for the last 14 days.
|
|
|
|
Newborns sleep 16-18 hours per day in short bursts (30min - 4 hours).
|
|
Sleep gradually consolidates over time.
|
|
"""
|
|
sleep_sessions = []
|
|
current_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
|
|
end_time = reference_time
|
|
|
|
day_number = 0
|
|
|
|
while current_time < end_time:
|
|
age_in_days = day_number
|
|
|
|
# Sleep patterns evolve with age
|
|
if age_in_days < 3:
|
|
# Very short, frequent naps
|
|
avg_wake_time = 1.5 # hours
|
|
sleep_duration_range = (30, 120) # minutes
|
|
elif age_in_days < 7:
|
|
# Slightly longer sleep periods
|
|
avg_wake_time = 2
|
|
sleep_duration_range = (45, 180)
|
|
else:
|
|
# More consolidated sleep
|
|
avg_wake_time = 2.5
|
|
sleep_duration_range = (60, 240)
|
|
|
|
# Random wake time with variation
|
|
wake_minutes = random.randint(int(avg_wake_time * 45), int(avg_wake_time * 75))
|
|
|
|
# Sleep start time
|
|
start_time = current_time + timedelta(minutes=wake_minutes)
|
|
|
|
if start_time >= end_time:
|
|
break
|
|
|
|
# Sleep duration
|
|
duration_minutes = random.randint(*sleep_duration_range)
|
|
|
|
# Longer sleep at night
|
|
if 20 <= start_time.hour or start_time.hour < 6:
|
|
duration_minutes = int(duration_minutes * 1.3)
|
|
|
|
end_time_sleep = start_time + timedelta(minutes=duration_minutes)
|
|
|
|
sleep_sessions.append(
|
|
{
|
|
"start_time": start_time,
|
|
"end_time": end_time_sleep,
|
|
}
|
|
)
|
|
|
|
current_time = end_time_sleep
|
|
birth_time = reference_time - timedelta(days=CHILD_AGE_DAYS)
|
|
day_number = (current_time - birth_time).days
|
|
|
|
return sleep_sessions
|
|
|
|
|
|
def generate_showcase_data(reference_time: datetime | None = None) -> dict:
|
|
"""
|
|
Generate all test data with timestamps relative to reference time.
|
|
|
|
Args:
|
|
reference_time: The "now" time to use as reference.
|
|
Defaults to current time.
|
|
|
|
Returns:
|
|
Dictionary containing all test data
|
|
"""
|
|
if reference_time is None:
|
|
reference_time = datetime.now()
|
|
|
|
return {
|
|
"users": SHOWCASE_USERS,
|
|
"child": get_child_data(reference_time),
|
|
"feedings": get_feeding_schedule(reference_time),
|
|
"diapers": get_diaper_changes(reference_time),
|
|
"sleep": get_sleep_sessions(reference_time),
|
|
"reference_time": reference_time,
|
|
}
|