Creating a CLI Habit Tracker with Python, SQLite, and Rich#

1
import sqlite3
2
from rich.console import Console
3

4
DATABASE_NAME = "habit_tracker.db"
5
console = Console()
6

7
def get_db_connection():
8
    """Establishes connection to the SQLite database."""
9
    conn = sqlite3.connect(DATABASE_NAME)
10
    conn.row_factory = sqlite3.Row # Allows accessing columns by name
11
    return conn
12

13
def create_tables():
14
    """Creates the necessary database tables if they don't exist."""
15
    conn = get_db_connection()
16
    cursor = conn.cursor()
17
    cursor.execute("""
18
        CREATE TABLE IF NOT EXISTS habits (
19
            id INTEGER PRIMARY KEY AUTOINCREMENT,
20
            name TEXT UNIQUE NOT NULL,
21
            periodicity TEXT NOT NULL,
22
            created_date TEXT NOT NULL
23
        )
24
    """)
25
    cursor.execute("""
26
        CREATE TABLE IF NOT EXISTS completions (
27
            id INTEGER PRIMARY KEY AUTOINCREMENT,
28
            habit_id INTEGER NOT NULL,
29
            completion_date TEXT NOT NULL,
30
            FOREIGN KEY (habit_id) REFERENCES habits(id)
31
        )
32
    """)
33
    conn.commit()
34
    conn.close()
35
    console.print("[green]Database initialized.[/green]")
36

37
# Call this function when the script starts or is first run
38
# create_tables()

1
import datetime
2

3
def add_habit(name, periodicity):
4
    """Adds a new habit to the database."""
5
    conn = get_db_connection()
6
    cursor = conn.cursor()
7
    created_date = datetime.date.today().isoformat()
8

9
    try:
10
        cursor.execute("""
11
            INSERT INTO habits (name, periodicity, created_date)
12
            VALUES (?, ?, ?)
13
        """, (name, periodicity, created_date))
14
        conn.commit()
15
        console.print(f"[green]Habit '{name}' ({periodicity}) added successfully.[/green]")
16
    except sqlite3.IntegrityError:
17
        console.print(f"[red]Error: Habit '{name}' already exists.[/red]")
18
    finally:
19
        conn.close()
20

21
# Example usage (assuming parsing arguments):
22
# add_habit("Read 30 mins", "daily")

1
def complete_habit(name):
2
    """Logs a completion for a habit."""
3
    conn = get_db_connection()
4
    cursor = conn.cursor()
5
    completion_date = datetime.date.today().isoformat()
6

7
    cursor.execute("SELECT id, periodicity FROM habits WHERE name = ?", (name,))
8
    habit = cursor.fetchone()
9

10
    if habit:
11
        habit_id = habit['id']
12
        periodicity = habit['periodicity']
13

14
        # Check for duplicate completion today (for daily habits)
15
        if periodicity.lower() == 'daily':
16
            cursor.execute("""
17
                SELECT COUNT(*) FROM completions
18
                WHERE habit_id = ? AND completion_date = ?
19
            """, (habit_id, completion_date))
20
            count = cursor.fetchone()[0]
21
            if count > 0:
22
                console.print(f"[yellow]Habit '{name}' already marked complete for today.[/yellow]")
23
                conn.close()
24
                return
25

26
        cursor.execute("""
27
            INSERT INTO completions (habit_id, completion_date)
28
            VALUES (?, ?)
29
        """, (habit_id, completion_date))
30
        conn.commit()
31
        console.print(f"[green]Habit '{name}' marked complete for {completion_date}.[/green]")
32
    else:
33
        console.print(f"[red]Error: Habit '{name}' not found.[/red]")
34

35
    conn.close()
36

37
# Example usage:
38
# complete_habit("Read 30 mins")

1
from rich.table import Table
2

3
def list_habits():
4
    """Lists all defined habits using Rich."""
5
    conn = get_db_connection()
6
    cursor = conn.cursor()
7
    cursor.execute("SELECT name, periodicity, created_date FROM habits")
8
    habits = cursor.fetchall()
9
    conn.close()
10

11
    if not habits:
12
        console.print("[italic]No habits found. Add one using the 'add' command.[/italic]")
13
        return
14

15
    table = Table(title="Your Habits")
16
    table.add_column("Name", style="cyan", no_wrap=True)
17
    table.add_column("Periodicity", style="magenta")
18
    table.add_column("Created Date", style="green")
19

20
    for habit in habits:
21
        table.add_row(habit['name'], habit['periodicity'], habit['created_date'])
22

23
    console.print(table)
24

25
def list_history(name):
26
    """Lists completion history for a specific habit using Rich."""
27
    conn = get_db_connection()
28
    cursor = conn.cursor()
29

30
    cursor.execute("SELECT id FROM habits WHERE name = ?", (name,))
31
    habit = cursor.fetchone()
32

33
    if not habit:
34
        console.print(f"[red]Error: Habit '{name}' not found.[/red]")
35
        conn.close()
36
        return
37

38
    habit_id = habit['id']
39
    cursor.execute("""
40
        SELECT completion_date FROM completions
41
        WHERE habit_id = ? ORDER BY completion_date DESC
42
    """, (habit_id,))
43
    completions = cursor.fetchall()
44
    conn.close()
45

46
    if not completions:
47
        console.print(f"[italic]No completions recorded for '{name}' yet.[/italic]")
48
        return
49

50
    table = Table(title=f"Completion History for '{name}'")
51
    table.add_column("Completion Date", style="green")
52

53
    for completion in completions:
54
        table.add_row(completion['completion_date'])
55

56
    console.print(table)
57

58
# Example usage:
59
# list_habits()
60
# list_history("Read 30 mins")

1
def calculate_daily_streak(completion_dates):
2
    """Calculates the current and longest daily streak."""
3
    if not completion_dates:
4
        return 0, 0
5

6
    # Convert date strings to date objects and sort
7
    dates = sorted([datetime.date.fromisoformat(d) for d in completion_dates])
8
    today = datetime.date.today()
9

10
    # Calculate current streak
11
    current_streak = 0
12
    # Start checking from today backwards, or yesterday if no completion today
13
    check_date = today if dates[-1] == today else today - datetime.timedelta(days=1)
14
    streak_date_index = len(dates) - 1 if dates[-1] == today else len(dates) # Start index for checking presence
15

16
    # If last completion was before yesterday, current streak is 0
17
    if dates[-1] < today - datetime.timedelta(days=1):
18
         current_streak = 0
19
    else:
20
        # If last completion was today, current streak starts at 1
21
        if dates[-1] == today:
22
            current_streak = 1
23
            check_date = today - datetime.timedelta(days=1) # Check the day before
24
            streak_date_index = len(dates) - 2 # Check from the second to last date
25
        # If last completion was yesterday, current streak starts at 1
26
        elif dates[-1] == today - datetime.timedelta(days=1):
27
             current_streak = 1
28
             check_date = today - datetime.timedelta(days=2)
29
             streak_date_index = len(dates) - 2
30
        else: # Last completion was earlier than yesterday
31
             current_streak = 0
32
             check_date = dates[-1] # No current streak to calculate, just longest
33

34
        # Continue checking backwards as long as dates are consecutive
35
        while streak_date_index >= 0 and dates[streak_date_index] == check_date:
36
             current_streak += 1
37
             check_date -= datetime.timedelta(days=1)
38
             streak_date_index -= 1
39

40

41
    # Calculate longest streak
42
    longest_streak = 0
43
    current_run = 0
44
    # Iterate through sorted dates to find longest consecutive sequence
45
    if dates:
46
        current_run = 1 # Start a run with the first date
47
        longest_streak = 1
48

49
        for i in range(1, len(dates)):
50
            # If the current date is exactly one day after the previous date
51
            if dates[i] == dates[i-1] + datetime.timedelta(days=1):
52
                current_run += 1
53
            elif dates[i] > dates[i-1] + datetime.timedelta(days=1):
54
                 # Gap found, start a new run
55
                 current_run = 1
56
            # If dates[i] == dates[i-1], it's a duplicate, ignore for streak
57
            longest_streak = max(longest_streak, current_run)
58

59
    # A specific case: if the longest streak ends yesterday and the dates don't include today
60
    # the calculation above might slightly undercount the 'potential' longest streak
61
    # if it ended yesterday. However, for simplicity, this covers the core logic.
62
    # More robust streak logic might involve checking if the last day of a run was <= yesterday.
63

64
    # Correct the current streak if today is not included and yesterday was the last day of a streak
65
    if today not in dates and dates and dates[-1] == today - datetime.timedelta(days=1) and current_streak == 1:
66
         # If only yesterday was completed, current streak is 1.
67
         # If it was part of a longer streak ending yesterday, the loop above captures it.
68
         pass # The loop logic handles this case correctly based on check_date
69

70
    return current_streak, longest_streak
71

72
def show_status(name):
73
    """Shows the status (including streaks) for a specific habit."""
74
    conn = get_db_connection()
75
    cursor = conn.cursor()
76

77
    cursor.execute("SELECT id, periodicity FROM habits WHERE name = ?", (name,))
78
    habit = cursor.fetchone()
79

80
    if not habit:
81
        console.print(f"[red]Error: Habit '{name}' not found.[/red]")
82
        conn.close()
83
        return
84

85
    habit_id = habit['id']
86
    periodicity = habit['periodicity']
87

88
    cursor.execute("""
89
        SELECT completion_date FROM completions
90
        WHERE habit_id = ? ORDER BY completion_date ASC
91
    """, (habit_id,))
92
    completions = [row['completion_date'] for row in cursor.fetchall()]
93
    conn.close()
94

95
    console.print(f"\n[bold]Status for '{name}' ({periodicity}):[/bold]")
96
    if not completions:
97
        console.print("[italic]No completions recorded yet.[/italic]")
98
        console.print("Current daily streak: 0")
99
        console.print("Longest daily streak: 0")
100
        return
101

102
    console.print(f"Last completion: {completions[-1]}")
103
    console.print(f"Total completions: {len(completions)}")
104

105
    # Streak calculation currently implemented for daily habits only
106
    if periodicity.lower() == 'daily':
107
        current, longest = calculate_daily_streak(completions)
108
        console.print(f"Current daily streak: [green]{current}[/green]")
109
        console.print(f"Longest daily streak: [magenta]{longest}[/magenta]")
110
    else:
111
         console.print(f"[italic]Streak calculation for '{periodicity}' habits not yet implemented.[/italic]")
112

113

114
# Example usage:
115
# show_status("Read 30 mins")

1
import argparse
2

3
def main():
4
    create_tables() # Ensure tables exist
5

6
    parser = argparse.ArgumentParser(description="Track your habits from the command line.")
7
    subparsers = parser.add_subparsers(dest='command', help='Available commands')
8

9
    # Add command
10
    add_parser = subparsers.add_parser('add', help='Add a new habit')
11
    add_parser.add_argument('name', type=str, help='Name of the habit')
12
    add_parser.add_argument('periodicity', type=str, choices=['daily', 'weekly'], help='Periodicity of the habit (daily or weekly)')
13

14
    # Complete command
15
    complete_parser = subparsers.add_parser('complete', help='Mark a habit as completed')
16
    complete_parser.add_argument('name', type=str, help='Name of the habit to complete')
17

18
    # List command
19
    list_parser = subparsers.add_parser('list', help='List all habits')
20

21
    # Status command
22
    status_parser = subparsers.add_parser('status', help='Show status and streaks for a habit')
23
    status_parser.add_argument('name', type=str, help='Name of the habit')
24

25
    args = parser.parse_args()
26

27
    if args.command == 'add':
28
        add_habit(args.name, args.periodicity)
29
    elif args.command == 'complete':
30
        complete_habit(args.name)
31
    elif args.command == 'list':
32
        list_habits()
33
    elif args.command == 'status':
34
        show_status(args.name)
35
    else:
36
        parser.print_help()
37

38
if __name__ == "__main__":
39
    main()