mkdir ~/projects/datetime-practice
cd ~/projects/datetime-practice
touch datetime_basics.py

# Option 1: Import the module
import datetime
print(datetime.date.today())
# Option 2: Import specific classes (most common)
from datetime import date, time, datetime, timedelta
print(date.today())
# Note: 'datetime' is both a module AND a class inside it
# This can be confusing at first

from datetime import date
# Create a specific date
birthday = date(2000, 6, 15)  # Year, Month, Day
print("Birthday:", birthday)
# Access components
print(f"Year: {birthday.year}")
print(f"Month: {birthday.month}")
print(f"Day: {birthday.day}")
# Invalid dates raise errors
# date(2026, 2, 30)  # ValueError: day is out of range for month

from datetime import date
today = date.today()
print("Today is:", today)
print(f"Year: {today.year}")
print(f"Month: {today.month}")
print(f"Day: {today.day}")
# Weekday (0=Monday, 6=Sunday)
print(f"Weekday number: {today.weekday()}")
# ISO weekday (1=Monday, 7=Sunday)
print(f"ISO weekday: {today.isoweekday()}")

from datetime import time
# Create a specific time
meeting = time(14, 30)  # 2:30 PM
print("Meeting time:", meeting)
# With seconds and microseconds
precise = time(14, 30, 45, 123456)
print("Precise time:", precise)
# Access components
print(f"Hour: {meeting.hour}")
print(f"Minute: {meeting.minute}")
print(f"Second: {meeting.second}")
print(f"Microsecond: {meeting.microsecond}")

from datetime import datetime
# Create a specific datetime
event = datetime(2026, 12, 25, 18, 30, 0)
print("Event:", event)
# Access date components
print(f"Year: {event.year}")
print(f"Month: {event.month}")
print(f"Day: {event.day}")
# Access time components
print(f"Hour: {event.hour}")
print(f"Minute: {event.minute}")
print(f"Second: {event.second}")

from datetime import datetime
# Current local datetime
now = datetime.now()
print("Now:", now)
# Current UTC datetime
utc_now = datetime.utcnow()
print("UTC:", utc_now)
# Just the date part
print("Date part:", now.date())
# Just the time part
print("Time part:", now.time())

from datetime import timedelta
# Create durations
one_day = timedelta(days=1)
one_week = timedelta(weeks=1)
two_hours = timedelta(hours=2)
thirty_minutes = timedelta(minutes=30)
print("One day:", one_day)
print("One week:", one_week)
print("Two hours:", two_hours)
print("30 minutes:", thirty_minutes)
# Combined
complex_duration = timedelta(days=2, hours=5, minutes=30)
print("2 days, 5 hours, 30 min:", complex_duration)

from datetime import date, timedelta
today = date.today()
print("Today:", today)
# Add days
tomorrow = today + timedelta(days=1)
next_week = today + timedelta(weeks=1)
print("Tomorrow:", tomorrow)
print("Next week:", next_week)
# Subtract days
yesterday = today - timedelta(days=1)
last_month = today - timedelta(days=30)
print("Yesterday:", yesterday)
print("30 days ago:", last_month)
# Difference between dates
new_years = date(2027, 1, 1)
days_until = new_years - today
print(f"Days until 2027: {days_until.days}")

from datetime import datetime, timedelta
now = datetime.now()
print("Now:", now)
# Add hours and minutes
meeting_start = now + timedelta(hours=2)
meeting_end = meeting_start + timedelta(minutes=45)
print("Meeting starts:", meeting_start)
print("Meeting ends:", meeting_end)
# Subtract to find past times
three_hours_ago = now - timedelta(hours=3)
print("3 hours ago:", three_hours_ago)
# Difference between datetimes
deadline = datetime(2026, 2, 1, 9, 0, 0)
remaining = deadline - now
print(f"Time until deadline: {remaining}")
print(f"That's {remaining.days} days and {remaining.seconds // 3600} hours")

from datetime import date, datetime
# Compare dates
today = date.today()
birthday = date(2026, 6, 15)
print(f"Today: {today}")
print(f"Birthday: {birthday}")
print(f"Birthday passed? {today > birthday}")
print(f"Birthday upcoming? {today < birthday}")
print(f"Is today birthday? {today == birthday}")
# Compare datetimes
now = datetime.now()
deadline = datetime(2026, 2, 1, 17, 0, 0)
if now < deadline:
    print("\nDeadline is in the future")
elif now > deadline:
    print("\nDeadline has passed")
else:
    print("\nIt's exactly the deadline!")

from datetime import datetime
now = datetime.now()
# Common formats
print(now.strftime("%Y-%m-%d"))              # 2026-01-28
print(now.strftime("%d/%m/%Y"))              # 28/01/2026
print(now.strftime("%B %d, %Y"))             # January 28, 2026
print(now.strftime("%H:%M:%S"))              # 14:30:45
print(now.strftime("%I:%M %p"))              # 02:30 PM
print(now.strftime("%A, %B %d, %Y"))         # Wednesday, January 28, 2026
print(now.strftime("%Y-%m-%d %H:%M:%S"))     # 2026-01-28 14:30:45
# Custom formats
print(now.strftime("Today is %A"))           # Today is Wednesday
print(now.strftime("Time: %H:%M"))           # Time: 14:30

from datetime import datetime
# Parse different formats
dt1 = datetime.strptime("2026-01-28", "%Y-%m-%d")
print("Parsed:", dt1)
dt2 = datetime.strptime("28/01/2026", "%d/%m/%Y")
print("Parsed:", dt2)
dt3 = datetime.strptime("January 28, 2026", "%B %d, %Y")
print("Parsed:", dt3)
dt4 = datetime.strptime("2026-01-28 14:30:00", "%Y-%m-%d %H:%M:%S")
print("Parsed with time:", dt4)
# Parse from user input
date_string = "2026-12-25"
christmas = datetime.strptime(date_string, "%Y-%m-%d")
print(f"Christmas is on a {christmas.strftime('%A')}")

from datetime import datetime, date
# ISO format output
now = datetime.now()
print("ISO datetime:", now.isoformat())
today = date.today()
print("ISO date:", today.isoformat())
# With custom separator
print("Custom sep:", now.isoformat(sep=' '))
# Parse ISO format
iso_string = "2026-01-28T14:30:00"
parsed = datetime.fromisoformat(iso_string)
print("Parsed ISO:", parsed)
# Also works with date
date_string = "2026-01-28"
parsed_date = date.fromisoformat(date_string)
print("Parsed date:", parsed_date)

from datetime import datetime
# Datetime to timestamp
now = datetime.now()
timestamp = now.timestamp()
print(f"Datetime: {now}")
print(f"Timestamp: {timestamp}")
# Timestamp to datetime
ts = 1737849600  # A specific moment
dt = datetime.fromtimestamp(ts)
print(f"\nTimestamp {ts}")
print(f"As datetime: {dt}")
# UTC timestamp to datetime
dt_utc = datetime.utcfromtimestamp(ts)
print(f"As UTC: {dt_utc}")
# Current timestamp shortcut
import time
print(f"\ntime.time(): {time.time()}")
print(f"datetime.now().timestamp(): {datetime.now().timestamp()}")

from datetime import datetime
now = datetime.now()
print("Now:", now)
# Change the year
next_year = now.replace(year=2027)
print("Next year:", next_year)
# Change multiple parts
midnight = now.replace(hour=0, minute=0, second=0, microsecond=0)
print("Today at midnight:", midnight)
# Set specific time
noon = now.replace(hour=12, minute=0, second=0, microsecond=0)
print("Today at noon:", noon)
# End of month
end_of_month = now.replace(day=31)  # Might fail if month doesn't have 31 days
# Safer: use calendar or go to next month and subtract

from datetime import date, timedelta
today = date.today()
print(f"Today: {today} ({today.strftime('%A')})")
print(f"Weekday: {today.weekday()} (0=Mon, 6=Sun)")
# Find next Monday
days_until_monday = (7 - today.weekday()) % 7
if days_until_monday == 0:
    days_until_monday = 7  # If today is Monday, get next Monday
next_monday = today + timedelta(days=days_until_monday)
print(f"Next Monday: {next_monday}")
# Find last Friday
days_since_friday = (today.weekday() - 4) % 7
if days_since_friday == 0:
    days_since_friday = 7  # If today is Friday, get last Friday
last_friday = today - timedelta(days=days_since_friday)
print(f"Last Friday: {last_friday}")
# Is it a weekend?
is_weekend = today.weekday() >= 5
print(f"Is weekend: {is_weekend}")
# Days until weekend
if today.weekday() < 5:  # Weekday
    days_to_weekend = 5 - today.weekday()
    print(f"Days until weekend: {days_to_weekend}")
else:
    print("It's the weekend!")

from datetime import datetime, timezone
# Naive datetime (no timezone info)
naive = datetime.now()
print(f"Naive: {naive}")
print(f"Timezone info: {naive.tzinfo}")
# UTC timezone-aware datetime
utc_now = datetime.now(timezone.utc)
print(f"\nUTC aware: {utc_now}")
print(f"Timezone info: {utc_now.tzinfo}")
# Check if aware or naive
print(f"\nNaive has tz? {naive.tzinfo is not None}")
print(f"UTC has tz? {utc_now.tzinfo is not None}")

from datetime import datetime, timezone, timedelta
# Create timezone with offset
eastern = timezone(timedelta(hours=-5))      # EST (UTC-5)
pacific = timezone(timedelta(hours=-8))      # PST (UTC-8)
india = timezone(timedelta(hours=5, minutes=30))  # IST (UTC+5:30)
# Get current time in different zones
utc_now = datetime.now(timezone.utc)
print(f"UTC:     {utc_now.strftime('%H:%M %Z')}")
eastern_now = utc_now.astimezone(eastern)
print(f"Eastern: {eastern_now.strftime('%H:%M %Z')}")
pacific_now = utc_now.astimezone(pacific)
print(f"Pacific: {pacific_now.strftime('%H:%M %Z')}")
india_now = utc_now.astimezone(india)
print(f"India:   {india_now.strftime('%H:%M %Z')}")

from datetime import datetime
try:
    from zoneinfo import ZoneInfo
except ImportError:
    print("zoneinfo requires Python 3.9+")
    exit()
# Named timezones (handle DST automatically)
eastern = ZoneInfo("America/New_York")
pacific = ZoneInfo("America/Los_Angeles")
london = ZoneInfo("Europe/London")
tokyo = ZoneInfo("Asia/Tokyo")
# Current time in each zone
now_utc = datetime.now(ZoneInfo("UTC"))
print(f"UTC:      {now_utc.strftime('%Y-%m-%d %H:%M %Z')}")
now_eastern = now_utc.astimezone(eastern)
print(f"New York: {now_eastern.strftime('%Y-%m-%d %H:%M %Z')}")
now_pacific = now_utc.astimezone(pacific)
print(f"LA:       {now_pacific.strftime('%Y-%m-%d %H:%M %Z')}")
now_london = now_utc.astimezone(london)
print(f"London:   {now_london.strftime('%Y-%m-%d %H:%M %Z')}")
now_tokyo = now_utc.astimezone(tokyo)
print(f"Tokyo:    {now_tokyo.strftime('%Y-%m-%d %H:%M %Z')}")

from datetime import datetime, timezone, timedelta
# Naive datetime
naive = datetime(2026, 6, 15, 14, 30)
print(f"Naive: {naive} (tzinfo={naive.tzinfo})")
# Add UTC timezone (assume it WAS UTC)
utc_aware = naive.replace(tzinfo=timezone.utc)
print(f"As UTC: {utc_aware}")
# Add custom timezone
eastern = timezone(timedelta(hours=-5))
eastern_aware = naive.replace(tzinfo=eastern)
print(f"As Eastern: {eastern_aware}")
# IMPORTANT: replace doesn't convert, it labels!
# These represent DIFFERENT moments in time:
print(f"\nUTC timestamp: {utc_aware.timestamp()}")
print(f"Eastern timestamp: {eastern_aware.timestamp()}")
print("(Different because they're different actual times)")

from datetime import date, datetime, timedelta
today = date.today()
# First day of current month
first_of_month = today.replace(day=1)
print(f"First of month: {first_of_month}")
# Last day of current month
next_month = (today.replace(day=28) + timedelta(days=4)).replace(day=1)
last_of_month = next_month - timedelta(days=1)
print(f"Last of month: {last_of_month}")
# First day of current year
first_of_year = today.replace(month=1, day=1)
print(f"First of year: {first_of_year}")
# Days remaining in year
dec_31 = date(today.year, 12, 31)
days_remaining = (dec_31 - today).days
print(f"Days left in year: {days_remaining}")
# Age calculation
birthdate = date(1990, 6, 15)
age = today.year - birthdate.year
if (today.month, today.day) < (birthdate.month, birthdate.day):
    age -= 1  # Birthday hasn't happened yet this year
print(f"Age: {age} years")

from datetime import date, timedelta
def date_range(start, end):
    """Generate dates from start to end (inclusive)."""
    current = start
    while current <= end:
        yield current
        current += timedelta(days=1)
# Generate a week of dates
start = date(2026, 1, 26)
end = date(2026, 2, 1)
print("Week of dates:")
for d in date_range(start, end):
    print(f"  {d} ({d.strftime('%A')})")
# Generate working days only
print("\nWorking days only:")
for d in date_range(start, end):
    if d.weekday() < 5:  # Monday-Friday
        print(f"  {d}")
# Count days
total = sum(1 for d in date_range(start, end))
work_days = sum(1 for d in date_range(start, end) if d.weekday() < 5)
print(f"\nTotal: {total} days, {work_days} working days")

from datetime import datetime
def parse_date_flexible(date_string):
    """Try multiple formats to parse a date string."""
    formats = [
        "%Y-%m-%d",           # 2026-01-28
        "%d/%m/%Y",           # 28/01/2026
        "%m/%d/%Y",           # 01/28/2026
        "%B %d, %Y",          # January 28, 2026
        "%d %B %Y",           # 28 January 2026
        "%Y-%m-%d %H:%M:%S",  # 2026-01-28 14:30:00
        "%d/%m/%Y %H:%M",     # 28/01/2026 14:30
    ]
    
    for fmt in formats:
        try:
            return datetime.strptime(date_string, fmt)
        except ValueError:
            continue
    
    raise ValueError(f"Cannot parse date: {date_string}")
# Test various formats
test_dates = [
    "2026-01-28",
    "28/01/2026",
    "January 28, 2026",
    "2026-01-28 14:30:00",
]
for date_str in test_dates:
    parsed = parse_date_flexible(date_str)
    print(f"'{date_str}' → {parsed}")

from datetime import timedelta
def format_duration(td):
    """Convert timedelta to human-readable string."""
    total_seconds = int(td.total_seconds())
    
    if total_seconds < 0:
        return "in the past"
    
    days, remainder = divmod(total_seconds, 86400)
    hours, remainder = divmod(remainder, 3600)
    minutes, seconds = divmod(remainder, 60)
    
    parts = []
    if days:
        parts.append(f"{days} day{'s' if days != 1 else ''}")
    if hours:
        parts.append(f"{hours} hour{'s' if hours != 1 else ''}")
    if minutes:
        parts.append(f"{minutes} minute{'s' if minutes != 1 else ''}")
    if seconds and not days:  # Skip seconds for long durations
        parts.append(f"{seconds} second{'s' if seconds != 1 else ''}")
    
    return ", ".join(parts) if parts else "0 seconds"
# Test various durations
durations = [
    timedelta(seconds=45),
    timedelta(minutes=5, seconds=30),
    timedelta(hours=2, minutes=15),
    timedelta(days=1, hours=5),
    timedelta(days=30),
]
for td in durations:
    print(f"{td} → {format_duration(td)}")

from datetime import datetime, timedelta
def countdown_to(event_name, event_datetime):
    """Print countdown to an event."""
    now = datetime.now()
    remaining = event_datetime - now
    
    if remaining.total_seconds() <= 0:
        print(f"{event_name} has already happened!")
        return
    
    days = remaining.days
    hours, remainder = divmod(remaining.seconds, 3600)
    minutes, seconds = divmod(remainder, 60)
    
    print(f"Countdown to {event_name}:")
    print(f"  {days} days, {hours} hours, {minutes} minutes, {seconds} seconds")
    
    # Milestones
    if days == 0:
        print("  🔥 It's TODAY!")
    elif days <= 7:
        print("  ⚡ Less than a week!")
    elif days <= 30:
        print("  📅 Less than a month!")
# Countdown to various events
new_year = datetime(2027, 1, 1, 0, 0, 0)
countdown_to("New Year 2027", new_year)
print()
# Countdown to a meeting
meeting = datetime.now() + timedelta(hours=3, minutes=30)
countdown_to("Team Meeting", meeting)

from datetime import datetime, timedelta
class Event:
    def __init__(self, name, dt):
        self.name = name
        self.datetime = dt
    
    def __repr__(self):
        return f"{self.name} @ {self.datetime.strftime('%Y-%m-%d %H:%M')}"
class Scheduler:
    def __init__(self):
        self.events = []
    
    def add(self, name, dt):
        self.events.append(Event(name, dt))
        self.events.sort(key=lambda e: e.datetime)
    
    def upcoming(self, n=5):
        """Get next n upcoming events."""
        now = datetime.now()
        future = [e for e in self.events if e.datetime > now]
        return future[:n]
    
    def today(self):
        """Get today's events."""
        now = datetime.now()
        return [e for e in self.events 
                if e.datetime.date() == now.date()]
# Demo
scheduler = Scheduler()
now = datetime.now()
scheduler.add("Team standup", now + timedelta(hours=1))
scheduler.add("Lunch", now + timedelta(hours=3))
scheduler.add("Code review", now + timedelta(hours=5))
scheduler.add("Tomorrow meeting", now + timedelta(days=1, hours=2))
scheduler.add("Past event", now - timedelta(hours=2))
print("All events:", scheduler.events)
print("\nUpcoming:", scheduler.upcoming(3))
print("\nToday:", scheduler.today())

from datetime import datetime, timedelta, date
def daily_occurrences(start_date, count):
    """Generate daily occurrences."""
    for i in range(count):
        yield start_date + timedelta(days=i)
def weekly_occurrences(start_date, count, weekday=None):
    """Generate weekly occurrences on same weekday."""
    if weekday is None:
        weekday = start_date.weekday()
    
    # Find first occurrence on target weekday
    days_ahead = weekday - start_date.weekday()
    if days_ahead < 0:
        days_ahead += 7
    first = start_date + timedelta(days=days_ahead)
    
    for i in range(count):
        yield first + timedelta(weeks=i)
def monthly_occurrences(start_date, count):
    """Generate monthly occurrences (same day of month)."""
    current = start_date
    for _ in range(count):
        yield current
        # Move to next month
        if current.month == 12:
            current = current.replace(year=current.year + 1, month=1)
        else:
            # Handle months with fewer days
            next_month = current.month + 1
            try:
                current = current.replace(month=next_month)
            except ValueError:
                # Day doesn't exist in next month, use last day
                current = current.replace(month=next_month, day=28)
# Demo
start = date(2026, 1, 28)
print("Daily (5 occurrences):")
for d in daily_occurrences(start, 5):
    print(f"  {d}")
print("\nWeekly on Monday (4 occurrences):")
for d in weekly_occurrences(start, 4, weekday=0):
    print(f"  {d} ({d.strftime('%A')})")
print("\nMonthly (6 occurrences):")
for d in monthly_occurrences(start, 6):
    print(f"  {d}")

from datetime import date, timedelta
def add_business_days(start_date, num_days):
    """Add business days (Mon-Fri) to a date."""
    current = start_date
    days_added = 0
    
    while days_added < num_days:
        current += timedelta(days=1)
        if current.weekday() < 5:  # Monday-Friday
            days_added += 1
    
    return current
def business_days_between(start_date, end_date):
    """Count business days between two dates."""
    count = 0
    current = start_date
    
    while current < end_date:
        current += timedelta(days=1)
        if current.weekday() < 5:
            count += 1
    
    return count
# Demo
today = date.today()
print(f"Today: {today} ({today.strftime('%A')})")
# Add 5 business days
deadline = add_business_days(today, 5)
print(f"5 business days later: {deadline} ({deadline.strftime('%A')})")
# Add 10 business days
deadline2 = add_business_days(today, 10)
print(f"10 business days later: {deadline2} ({deadline2.strftime('%A')})")
# Count business days in January
jan_start = date(2026, 1, 1)
jan_end = date(2026, 1, 31)
work_days = business_days_between(jan_start, jan_end)
print(f"\nBusiness days in January 2026: {work_days}")

from datetime import timedelta
# Basic arithmetic
hour = timedelta(hours=1)
day = timedelta(days=1)
print(f"1 day + 2 hours: {day + 2*hour}")
print(f"1 day - 6 hours: {day - 6*hour}")
print(f"3 days * 2: {3*day}")
print(f"1 week / 2: {timedelta(weeks=1) / 2}")
# Total seconds
week = timedelta(weeks=1)
print(f"\n1 week = {week.total_seconds()} seconds")
print(f"1 week = {week.total_seconds() / 3600} hours")
print(f"1 week = {week.days} days")
# Comparisons
short = timedelta(hours=1)
long = timedelta(days=1)
print(f"\n1 hour < 1 day: {short < long}")
print(f"1 hour == 60 minutes: {short == timedelta(minutes=60)}")
# Absolute value
negative = timedelta(days=-5)
print(f"\nNegative duration: {negative}")
print(f"Absolute value: {abs(negative)}")

import calendar
from datetime import date
# Print a month calendar
print("January 2026:")
print(calendar.month(2026, 1))
# Days in a month
days_in_feb = calendar.monthrange(2026, 2)[1]
print(f"Days in Feb 2026: {days_in_feb}")
# Is leap year?
print(f"2024 is leap year: {calendar.isleap(2024)}")
print(f"2026 is leap year: {calendar.isleap(2026)}")
# First and last day of month
today = date.today()
first_weekday, num_days = calendar.monthrange(today.year, today.month)
first_day = today.replace(day=1)
last_day = today.replace(day=num_days)
print(f"\nThis month: {first_day} to {last_day}")
# All Sundays in a month
print("\nSundays in January 2026:")
cal = calendar.Calendar()
for day in cal.itermonthdays2(2026, 1):
    date_num, weekday = day
    if date_num != 0 and weekday == 6:  # 6 = Sunday
        print(f"  January {date_num}")

from datetime import datetime, date
def is_valid_date(year, month, day):
    """Check if a date is valid."""
    try:
        date(year, month, day)
        return True
    except ValueError:
        return False
def parse_date_safe(date_string, format="%Y-%m-%d"):
    """Parse date, return None if invalid."""
    try:
        return datetime.strptime(date_string, format)
    except ValueError:
        return None
def validate_date_range(start, end):
    """Ensure start is before end."""
    if start > end:
        raise ValueError("Start date must be before end date")
    return True
# Test validation
print("Date validation:")
print(f"  2026-02-28: {is_valid_date(2026, 2, 28)}")  # Valid
print(f"  2026-02-29: {is_valid_date(2026, 2, 29)}")  # Invalid (not leap year)
print(f"  2024-02-29: {is_valid_date(2024, 2, 29)}")  # Valid (leap year)
print(f"  2026-13-01: {is_valid_date(2026, 13, 1)}")  # Invalid month
print("\nParsing:")
print(f"  '2026-01-28': {parse_date_safe('2026-01-28')}")
print(f"  'invalid': {parse_date_safe('invalid')}")
print(f"  '28/01/2026': {parse_date_safe('28/01/2026')}")  # Wrong format
print("\nRange validation:")
try:
    validate_date_range(date(2026, 1, 1), date(2026, 12, 31))
    print("  Valid range ✓")
except ValueError as e:
    print(f"  Error: {e}")

from datetime import datetime, date, timedelta, timezone
# Pattern 1: Today at midnight
today_midnight = datetime.combine(date.today(), datetime.min.time())
# Pattern 2: End of today
today_end = datetime.combine(date.today(), datetime.max.time())
# Pattern 3: First day of month
first_of_month = date.today().replace(day=1)
# Pattern 4: Days until date
target = date(2026, 12, 25)
days_until = (target - date.today()).days
# Pattern 5: Is date in past?
is_past = date(2020, 1, 1) < date.today()
# Pattern 6: Format for display
display = datetime.now().strftime("%B %d, %Y at %I:%M %p")
# Pattern 7: Parse ISO date
dt = datetime.fromisoformat("2026-01-28T14:30:00")
# Pattern 8: Current UTC timestamp
utc_now = datetime.now(timezone.utc)
# Pattern 9: Add months (approximate)
def add_months(dt, months):
    month = dt.month + months
    year = dt.year + (month - 1) // 12
    month = (month - 1) % 12 + 1
    day = min(dt.day, [31,28,31,30,31,30,31,31,30,31,30,31][month-1])
    return dt.replace(year=year, month=month, day=day)
# Pattern 10: Time since event
event_time = datetime(2026, 1, 1, 0, 0, 0)
time_since = datetime.now() - event_time
print("Patterns demonstrated successfully!")
print(f"Today midnight: {today_midnight}")
print(f"Days until Christmas: {days_until}")
print(f"Display format: {display}")