1
#!/usr/bin/env python3
2
"""Middle Path — a small reflective ritual for the terminal."""
3
​
4
from __future__ import annotations
5
​
6
import os
7
import random
8
import sys
9
import time
10
from typing import Final
11
​
12
# -- Constants ---------------------------------------------------------------
13
​
14
INPUT_MIN: Final[int] = -5
15
INPUT_MAX: Final[int] = 5
16
MIN_PAIRS: Final[int] = 5
17
MAX_PAIRS: Final[int] = 8
18
PAUSE_SHORT: Final[float] = 0.4
19
PAUSE_LONG: Final[float] = 0.8
20
​
21
DITCH_THRESHOLD: Final[int] = 4
22
LEANING_THRESHOLD: Final[int] = 2
23
​
24
ALL_PAIRS: Final[list[tuple[str, str]]] = [
25
    ("Indulgence", "Denial"),
26
    ("Holding", "Releasing"),
27
    ("Knowing", "Not knowing"),
28
    ("Self", "No-self"),
29
    ("Effort", "Collapse"),
30
    ("Control", "Letting go"),
31
    ("Clinging", "Avoidance"),
32
    ("Certainty", "Confusion"),
33
    ("Doing too much", "Doing nothing"),
34
]
35
​
36
GREETING: Final[str] = """
37
You are walking.
38
​
39
Stay between the ditches.
40
​
41
Press Enter to begin.
42
"""
43
​
44
FAREWELL: Final[str] = """
45
You are still walking.
46
​
47
Not perfect.
48
Not lost.
49
​
50
Just here.
51
"""
52
​
53
​
54
# -- Position classification -------------------------------------------------
55
​
56
class Position:
57
    """Named constants for classified positions on the path."""
58
​
59
    DITCH: Final[str] = "ditch"
60
    LEANING: Final[str] = "leaning"
61
    STEADY: Final[str] = "steady"
62
​
63
​
64
# -- Functions ---------------------------------------------------------------
65
​
66
​
67
def clear_screen() -> None:
68
    """Clear the terminal screen."""
69
    os.system("cls" if os.name == "nt" else "clear")  # noqa: S605
70
​
71
​
72
def print_greeting() -> None:
73
    """Display the opening message and wait for the user to begin."""
74
    print(GREETING)
75
    input()
76
​
77
​
78
def get_pairs() -> list[tuple[str, str]]:
79
    """Select and shuffle a random subset of tension pairs.
80
​
81
    Returns:
82
        A list of 5-8 tension pairs in random order.
83
    """
84
    count = random.randint(MIN_PAIRS, MAX_PAIRS)
85
    pairs = random.sample(ALL_PAIRS, count)
86
    return pairs
87
​
88
​
89
def present_pair(pair: tuple[str, str]) -> None:
90
    """Display a tension pair with its visual scale.
91
​
92
    Args:
93
        pair: A tuple of (left_label, right_label).
94
    """
95
    left, right = pair
96
    print()
97
    print(f"{left}   <------------------>   {right}")
98
    print()
99
    print(f"Where are you right now?  ({INPUT_MIN} to +{INPUT_MAX})")
100
    print()
101
​
102
​
103
def get_input() -> int:
104
    """Read and validate an integer from the user.
105
​
106
    Reprompts gently until a valid integer in range is provided.
107
​
108
    Returns:
109
        An integer between INPUT_MIN and INPUT_MAX inclusive.
110
    """
111
    while True:
112
        try:
113
            raw = input("> ").strip()
114
            value = int(raw)
115
        except ValueError:
116
            print()
117
            print("A number, please.")
118
            print()
119
            continue
120
        except (EOFError, KeyboardInterrupt):
121
            print()
122
            sys.exit(0)
123
​
124
        if INPUT_MIN <= value <= INPUT_MAX:
125
            return value
126
​
127
        print()
128
        print(f"Between {INPUT_MIN} and +{INPUT_MAX}.")
129
        print()
130
​
131
​
132
def classify_position(value: int) -> str:
133
    """Classify a position value into a named category.
134
​
135
    Args:
136
        value: An integer in the range INPUT_MIN to INPUT_MAX.
137
​
138
    Returns:
139
        One of Position.DITCH, Position.LEANING, or Position.STEADY.
140
    """
141
    magnitude = abs(value)
142
​
143
    if magnitude >= DITCH_THRESHOLD:
144
        return Position.DITCH
145
    if magnitude >= LEANING_THRESHOLD:
146
        return Position.LEANING
147
    return Position.STEADY
148
​
149
​
150
def respond(position: str) -> str:
151
    """Return a gentle response for the given position classification.
152
​
153
    Args:
154
        position: One of the Position constants.
155
​
156
    Returns:
157
        A short reflective message.
158
    """
159
    responses: dict[str, str] = {
160
        Position.DITCH: (
161
            "You slipped into the ditch.\n"
162
            "Return to the path."
163
        ),
164
        Position.LEANING: "Careful. You're leaning.",
165
        Position.STEADY: "Steady. Walking.",
166
    }
167
    return responses[position]
168
​
169
​
170
def main() -> None:
171
    """Run a single session of Middle Path."""
172
    clear_screen()
173
    print_greeting()
174
​
175
    pairs = get_pairs()
176
​
177
    for pair in pairs:
178
        present_pair(pair)
179
​
180
        while True:
181
            value = get_input()
182
            position = classify_position(value)
183
            message = respond(position)
184
​
185
            print()
186
            time.sleep(PAUSE_SHORT)
187
            print(message)
188
            time.sleep(PAUSE_LONG)
189
​
190
            if position != Position.DITCH:
191
                break
192
​
193
            # Ditch: repeat the same pair.
194
            print()
195
​
196
    print(FAREWELL)
197
​
198
​
199
if __name__ == "__main__":
200
    main()
201
​