| """Main window: live control, editable session list, daily focus, projects, charts and settings."""
|
| import csv
|
| import time
|
| import tkinter as tk
|
| from collections import defaultdict
|
| from datetime import date, datetime, timedelta
|
| from tkinter import filedialog, messagebox, simpledialog, ttk
|
|
|
| from db import MIN_SESSION_S
|
|
|
| RED, ORANGE, GREEN, GRAY = "#ff453a", "#ff9f0a", "#34c759", "#8e8e93"
|
| ACCENT = "#2f7dd1"
|
| BG, CARD, TEXT, MUTED, LINE = "#f2f2f7", "#ffffff", "#1c1c1e", "#6e6e73", "#e1e1e6"
|
| DISC, TRACK = "#1c1c1e", "#3a3a3c"
|
| RANGES = {"Last 7 days": 7, "Last 30 days": 30, "Last 90 days": 90, "All time": None}
|
| SHOW = {"Today": 1, "Last 7 days": 7, "Last 30 days": 30, "All time": None}
|
| WEEKDAYS = ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
|
| DT_FORMATS = ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%dT%H:%M:%S", "%Y-%m-%dT%H:%M")
|
| CSV_COLUMNS = ["start", "end", "minutes", "plan_minutes", "plan_met", "project"]
|
|
|
|
|
| def plan_color(elapsed, plan_s):
|
| """Red below half of the plan, orange up to the plan, green once it is reached."""
|
| frac = elapsed / plan_s
|
| return RED if frac < 0.5 else ORANGE if frac < 1 else GREEN
|
|
|
|
|
| def split_hours(sessions):
|
| """Yield (hour_start, seconds, project), cutting every session at hour boundaries."""
|
| for _, project, start, end, _plan in sessions:
|
| cur = datetime.fromtimestamp(start)
|
| stop = datetime.fromtimestamp(end)
|
| while cur < stop:
|
| hour = cur.replace(minute=0, second=0, microsecond=0)
|
| seg = min(stop, hour + timedelta(hours=1))
|
| yield hour, (seg - cur).total_seconds(), project
|
| cur = seg
|
|
|
|
|
| def fmt_hm(seconds):
|
| m = int(round(seconds / 60))
|
| return f"{m // 60}h {m % 60:02d}m"
|
|
|
|
|
| def mmss(seconds):
|
| seconds = int(seconds)
|
| return f"{seconds // 60:02d}:{seconds % 60:02d}"
|
|
|
|
|
| def plan_met(start, end, plan):
|
| return bool(plan) and end - start >= plan * 60
|
|
|
|
|
| def plan_text(start, end, plan):
|
| if not plan:
|
| return ""
|
| return f"{plan}m ✓" if plan_met(start, end, plan) else f"{plan}m"
|
|
|
|
|
| def parse_dt(text):
|
| text = text.strip()
|
| for fmt in DT_FORMATS:
|
| try:
|
| return int(datetime.strptime(text, fmt).timestamp())
|
| except ValueError:
|
| pass
|
| raise ValueError(f"Cannot read date/time '{text}' (use YYYY-MM-DD HH:MM[:SS])")
|
|
|
|
|
| def fmt_dt(ts):
|
| return datetime.fromtimestamp(ts).strftime("%Y-%m-%d %H:%M:%S")
|
|
|
|
|
| def apply_style(win):
|
| st = ttk.Style(win)
|
| st.theme_use("clam")
|
| win.configure(bg=BG)
|
| base = ("Segoe UI", 10)
|
| st.configure(".", background=BG, foreground=TEXT, font=base, bordercolor=LINE, focuscolor=BG)
|
| st.configure("TFrame", background=BG)
|
| st.configure("Card.TFrame", background=CARD, relief="solid", borderwidth=1, bordercolor=LINE)
|
| st.configure("Plain.TFrame", background=CARD)
|
| st.configure("TLabel", background=BG)
|
| st.configure("Card.TLabel", background=CARD)
|
| st.configure("Muted.TLabel", background=BG, foreground=MUTED)
|
| st.configure("CardMuted.TLabel", background=CARD, foreground=MUTED)
|
| st.configure("Title.TLabel", background=CARD, font=("Segoe UI Semibold", 11))
|
| st.configure("Stat.TLabel", background=CARD, font=("Segoe UI Semibold", 18))
|
| st.configure("TNotebook", background=BG, borderwidth=0, tabmargins=(0, 0, 0, 0))
|
| st.configure("TNotebook.Tab", padding=(18, 9), font=("Segoe UI Semibold", 10), background=BG, foreground=MUTED)
|
| st.map("TNotebook.Tab", background=[("selected", CARD)], foreground=[("selected", ACCENT)])
|
| st.configure("Treeview", rowheight=30, background=CARD, fieldbackground=CARD, borderwidth=0, font=base)
|
| st.configure("Treeview.Heading", background="#eceff3", foreground=MUTED, relief="flat",
|
| font=("Segoe UI Semibold", 9), padding=(8, 6))
|
| st.map("Treeview", background=[("selected", ACCENT)], foreground=[("selected", "white")])
|
| st.configure("TButton", padding=(12, 6), background="#eef0f4", borderwidth=1, relief="flat")
|
| st.map("TButton", background=[("active", "#eaf2fb")])
|
| st.configure("Accent.TButton", background=ACCENT, foreground="white", padding=(12, 6))
|
| st.map("Accent.TButton", background=[("active", "#256bb8")])
|
| st.configure("Danger.TButton", foreground=RED)
|
| st.configure("TCheckbutton", background=BG)
|
| st.configure("TCombobox", padding=4, fieldbackground="white")
|
| st.map("TCombobox", fieldbackground=[("readonly", "white")], background=[("readonly", "#eef0f4")])
|
| st.configure("TSpinbox", padding=4, fieldbackground="white")
|
|
|
|
|
| def make_tree(parent, cols, widths):
|
| frame = ttk.Frame(parent, style="Plain.TFrame")
|
| tree = ttk.Treeview(frame, columns=cols, show="headings", selectmode="browse")
|
| for c, w in zip(cols, widths):
|
| tree.heading(c, text=c)
|
| tree.column(c, width=w, anchor="w")
|
| tree.tag_configure("odd", background="#f7f8fa")
|
| tree.tag_configure("met", foreground="#1e8e3e")
|
| scroll = ttk.Scrollbar(frame, command=tree.yview)
|
| tree.configure(yscrollcommand=scroll.set)
|
| tree.pack(side="left", fill="both", expand=True)
|
| scroll.pack(side="right", fill="y")
|
| return frame, tree
|
|
|
|
|
| def fill(tree, rows):
|
| """Replace the rows (iid, values[, tags]) but keep selection and scroll position."""
|
| sel, top = set(tree.selection()), tree.yview()[0]
|
| tree.delete(*tree.get_children())
|
| for i, (iid, values, *extra) in enumerate(rows):
|
| tags = (("odd",) if i % 2 else ()) + tuple(extra[0] if extra else ())
|
| tree.insert("", "end", iid=iid, values=values, tags=tags)
|
| keep = [i for i in sel if tree.exists(i)]
|
| if keep:
|
| tree.selection_set(keep)
|
| tree.yview_moveto(top)
|
|
|
|
|
| class SessionDialog(tk.Toplevel):
|
| """Add or edit one session: project, start, end, plan."""
|
|
|
| def __init__(self, parent, projects, session=None):
|
| super().__init__(parent)
|
| self.result = None
|
| self.title("Edit session" if session else "Add session")
|
| self.configure(bg=BG)
|
| self.transient(parent)
|
| self.resizable(False, False)
|
| card = ttk.Frame(self, style="Card.TFrame", padding=16)
|
| card.pack(padx=14, pady=14)
|
|
|
| _, project, start, end, plan = session or (None, "", int(time.time()) - 1200, int(time.time()), 20)
|
| self.vars = {
|
| "project": tk.StringVar(value=project),
|
| "start": tk.StringVar(value=fmt_dt(start)),
|
| "end": tk.StringVar(value=fmt_dt(end)),
|
| "plan": tk.StringVar(value=str(plan or "")),
|
| }
|
| rows = [("Project", "project"), ("Start", "start"), ("End", "end"), ("Plan (minutes)", "plan")]
|
| for r, (label, key) in enumerate(rows):
|
| ttk.Label(card, text=label, style="Card.TLabel").grid(row=r, column=0, sticky="w", pady=5, padx=(0, 14))
|
| if key == "project":
|
| w = ttk.Combobox(card, textvariable=self.vars[key], values=projects, width=30)
|
| else:
|
| w = ttk.Entry(card, textvariable=self.vars[key], width=32)
|
| w.grid(row=r, column=1, pady=5)
|
| ttk.Label(card, text="Format: YYYY-MM-DD HH:MM:SS", style="CardMuted.TLabel").grid(
|
| row=4, column=1, sticky="w")
|
| btns = ttk.Frame(card, style="Plain.TFrame")
|
| btns.grid(row=5, column=0, columnspan=2, sticky="e", pady=(14, 0))
|
| ttk.Button(btns, text="Cancel", command=self.destroy).pack(side="right")
|
| ttk.Button(btns, text="Save", style="Accent.TButton", command=self.save).pack(side="right", padx=8)
|
| self.bind("<Return>", lambda e: self.save())
|
| self.bind("<Escape>", lambda e: self.destroy())
|
| self.update_idletasks()
|
| self.geometry(f"+{parent.winfo_rootx() + 140}+{parent.winfo_rooty() + 120}")
|
| self.grab_set()
|
| self.wait_window()
|
|
|
| def save(self):
|
| try:
|
| project = self.vars["project"].get().strip()
|
| if not project:
|
| raise ValueError("Project name is required.")
|
| start, end = parse_dt(self.vars["start"].get()), parse_dt(self.vars["end"].get())
|
| if end - start < MIN_SESSION_S:
|
| raise ValueError("End must be later than start.")
|
| plan_text_ = self.vars["plan"].get().strip()
|
| plan = int(plan_text_) if plan_text_ else None
|
| if plan is not None and plan < 1:
|
| raise ValueError("Plan must be at least 1 minute (or empty).")
|
| except ValueError as e:
|
| messagebox.showerror("Session", str(e), parent=self)
|
| return
|
| self.result = (project, start, end, plan)
|
| self.destroy()
|
|
|
|
|
| class MainWindow:
|
| def __init__(self, app):
|
| self.app = app
|
| self.win = win = app.root
|
| apply_style(win)
|
| win.title("Focus Tracker")
|
| h = min(980, int(win.winfo_screenheight() * 0.92))
|
| win.geometry(f"1180x{h}+40+10")
|
| win.minsize(980, 640)
|
|
|
| bar = ttk.Frame(win, padding=(16, 12, 16, 4))
|
| bar.pack(fill="x")
|
| ttk.Label(bar, text="Focus Tracker", font=("Segoe UI Semibold", 16)).pack(side="left")
|
| ttk.Button(bar, text="Export CSV", command=self.export_csv).pack(side="right")
|
| ttk.Button(bar, text="Import CSV", command=self.import_csv).pack(side="right", padx=8)
|
|
|
| self.tabs = ttk.Notebook(win)
|
| self.tabs.pack(fill="both", expand=True, padx=12, pady=(4, 12))
|
| self._build_home()
|
| self._build_daily()
|
| self._build_projects()
|
| self._build_charts()
|
| self._build_settings()
|
| self.tabs.bind("<<NotebookTabChanged>>", lambda e: self.refresh())
|
|
|
| self.refresh()
|
| self._live()
|
| self._auto()
|
|
|
| def visible(self):
|
| return self.win.state() != "withdrawn"
|
|
|
| def _auto(self):
|
| self.refresh()
|
| self.win.after(30000, self._auto)
|
|
|
|
|
| def _spin(self, parent, key, default, lo, hi, cast=int, increment=1, after=None, width=6):
|
| db = self.app.db
|
| var = tk.StringVar(value=str(cast(float(db.get(key, default)))))
|
|
|
| def commit(*_):
|
| try:
|
| v = min(hi, max(lo, cast(float(var.get()))))
|
| except ValueError:
|
| v = cast(float(db.get(key, default)))
|
| var.set(str(v))
|
| db.set(key, v)
|
| if after:
|
| after(v)
|
|
|
| sp = ttk.Spinbox(parent, from_=lo, to=hi, increment=increment, textvariable=var,
|
| width=width, command=commit)
|
| sp.bind("<Return>", commit)
|
| sp.bind("<FocusOut>", commit)
|
| return sp, var
|
|
|
| def _stat_card(self, parent, col, title):
|
| card = ttk.Frame(parent, style="Card.TFrame", padding=(14, 8))
|
| card.grid(row=0, column=col, sticky="nsew", padx=(0 if col == 0 else 10, 0))
|
| parent.columnconfigure(col, weight=1, uniform="stat")
|
| ttk.Label(card, text=title, style="CardMuted.TLabel").pack(anchor="w")
|
| value = ttk.Label(card, style="Stat.TLabel")
|
| value.pack(anchor="w")
|
| sub = ttk.Label(card, style="CardMuted.TLabel")
|
| sub.pack(anchor="w")
|
| return value, sub
|
|
|
|
|
| def _build_home(self):
|
| f = ttk.Frame(self.tabs, padding=(4, 14, 4, 4))
|
| self.tabs.add(f, text=" Home ")
|
|
|
| top = ttk.Frame(f)
|
| top.pack(fill="x")
|
| top.columnconfigure(1, weight=1)
|
|
|
| hero = ttk.Frame(top, style="Card.TFrame", padding=14)
|
| hero.grid(row=0, column=0, sticky="ns")
|
| self.ring = c = tk.Canvas(hero, width=200, height=200, bg=CARD, highlightthickness=0)
|
| c.pack()
|
| c.create_oval(4, 4, 196, 196, fill=DISC, outline="")
|
| c.create_oval(20, 20, 180, 180, outline=TRACK, width=10)
|
| self.r_arc = c.create_arc(20, 20, 180, 180, start=90, extent=0, style="arc", outline=GRAY, width=10)
|
| self.r_time = c.create_text(100, 86, text="00:00", fill="white", font=("Segoe UI Semibold", 24))
|
| self.r_sub = c.create_text(100, 126, text="", fill=GRAY, font=("Segoe UI", 9))
|
| self.r_status = ttk.Label(hero, style="Title.TLabel")
|
| self.r_status.pack(pady=(8, 0))
|
|
|
| ctrl = ttk.Frame(top, style="Card.TFrame", padding=14)
|
| ctrl.grid(row=0, column=1, sticky="nsew", padx=(10, 0))
|
| grid = ttk.Frame(ctrl, style="Plain.TFrame")
|
| grid.pack(fill="x")
|
| ttk.Label(grid, text="Project", style="CardMuted.TLabel").grid(row=0, column=0, sticky="w")
|
| self.project_var = tk.StringVar(value=self.app.project)
|
| self.project_box = ttk.Combobox(grid, textvariable=self.project_var, width=30, font=("Segoe UI", 11))
|
| self.project_box.grid(row=1, column=0, sticky="w", pady=(2, 8), padx=(0, 20))
|
| for ev in ("<<ComboboxSelected>>", "<Return>", "<FocusOut>"):
|
| self.project_box.bind(ev, self._project_chosen)
|
| ttk.Label(grid, text="Plan (minutes)", style="CardMuted.TLabel").grid(row=0, column=1, sticky="w")
|
| self.plan_spin, self.plan_var = self._spin(grid, "plan_min", 20, 1, 240, after=self.app.set_plan, width=6)
|
| self.plan_spin.grid(row=1, column=1, sticky="w", pady=(2, 8))
|
|
|
| self.btn = tk.Button(ctrl, text="Start", font=("Segoe UI Semibold", 13), fg="white", bg=GREEN,
|
| activebackground="#2aa84f", activeforeground="white", relief="flat",
|
| cursor="hand2", pady=4, command=self.app.toggle)
|
| self.btn.pack(fill="x", pady=(0, 8))
|
|
|
| hk = ttk.Frame(ctrl, style="Plain.TFrame")
|
| hk.pack(fill="x")
|
| ttk.Label(hk, text="Hotkey", style="CardMuted.TLabel").pack(side="left")
|
| ttk.Label(hk, textvariable=self.app.hotkey_var, style="Title.TLabel").pack(side="left", padx=10)
|
| ttk.Button(hk, text="Change...", command=self.app.capture_hotkey).pack(side="left")
|
|
|
| legend = ttk.Frame(ctrl, style="Plain.TFrame")
|
| legend.pack(fill="x", pady=(8, 0))
|
| for color, text in ((RED, "under half of the plan"), (ORANGE, "past half"), (GREEN, "plan reached")):
|
| tk.Label(legend, text="●", fg=color, bg=CARD, font=("Segoe UI", 12)).pack(side="left")
|
| ttk.Label(legend, text=text + " ", style="CardMuted.TLabel").pack(side="left")
|
|
|
| stats = ttk.Frame(f)
|
| stats.pack(fill="x", pady=10)
|
| self.s_today = self._stat_card(stats, 0, "Today")
|
| self.s_week = self._stat_card(stats, 1, "This week")
|
| self.s_streak = self._stat_card(stats, 2, "Streak")
|
| self.s_plans = self._stat_card(stats, 3, "Plans met today")
|
|
|
| box = ttk.Frame(f, style="Card.TFrame", padding=12)
|
| box.pack(fill="both", expand=True)
|
| head = ttk.Frame(box, style="Plain.TFrame")
|
| head.pack(fill="x", pady=(0, 8))
|
| ttk.Label(head, text="Sessions", style="Title.TLabel").pack(side="left")
|
| self.show_var = tk.StringVar(value="Today")
|
| show = ttk.Combobox(head, textvariable=self.show_var, values=list(SHOW), state="readonly", width=13)
|
| show.pack(side="left", padx=(14, 6))
|
| self.filter_var = tk.StringVar(value="All projects")
|
| self.filter_box = ttk.Combobox(head, textvariable=self.filter_var, state="readonly", width=22)
|
| self.filter_box.pack(side="left")
|
| for w in (show, self.filter_box):
|
| w.bind("<<ComboboxSelected>>", lambda e: self.refresh())
|
| ttk.Button(head, text="Delete", width=8, style="Danger.TButton", command=self.delete_session).pack(side="right")
|
| ttk.Button(head, text="Edit...", width=8, command=self.edit_session).pack(side="right", padx=6)
|
| ttk.Button(head, text="Add...", width=8, command=self.add_session).pack(side="right")
|
| frame, self.sess_tree = make_tree(
|
| box, ("Date", "Start", "End", "Duration", "Plan", "Project"), (110, 90, 90, 100, 90, 360))
|
| frame.pack(fill="both", expand=True)
|
| self.sess_tree.bind("<Double-1>", lambda e: self.edit_session())
|
| self.sess_tree.bind("<Delete>", lambda e: self.delete_session())
|
|
|
|
|
| def _build_daily(self):
|
| f = ttk.Frame(self.tabs, padding=(4, 14, 4, 4))
|
| self.tabs.add(f, text=" Daily ")
|
| bar = ttk.Frame(f)
|
| bar.pack(fill="x", pady=(0, 8))
|
| ttk.Label(bar, text="Range", style="Muted.TLabel").pack(side="left")
|
| self.range_var = tk.StringVar(value="Last 30 days")
|
| box = ttk.Combobox(bar, textvariable=self.range_var, values=list(RANGES), state="readonly", width=14)
|
| box.pack(side="left", padx=8)
|
| box.bind("<<ComboboxSelected>>", lambda e: self.refresh())
|
| frame, self.daily_tree = make_tree(
|
| f, ("Date", "Day", "Focus", "Sessions", "Plans met", "Projects"), (110, 60, 90, 80, 90, 600))
|
| frame.pack(fill="both", expand=True)
|
|
|
| def _build_projects(self):
|
| f = ttk.Frame(self.tabs, padding=(4, 14, 4, 4))
|
| self.tabs.add(f, text=" Projects ")
|
| btns = ttk.Frame(f)
|
| btns.pack(fill="x", pady=(0, 8))
|
| ttk.Button(btns, text="Add...", command=self.add_project).pack(side="left")
|
| ttk.Button(btns, text="Rename...", command=self.rename_project).pack(side="left", padx=6)
|
| ttk.Button(btns, text="Delete", style="Danger.TButton", command=self.delete_project).pack(side="left")
|
| frame, self.proj_tree = make_tree(f, ("Project", "Total", "Sessions", "Last used"), (320, 110, 90, 130))
|
| frame.pack(fill="both", expand=True)
|
|
|
| def _build_charts(self):
|
| f = ttk.Frame(self.tabs, padding=(4, 8, 4, 4))
|
| self.tabs.add(f, text=" Charts ")
|
| self.charts_tab = f
|
| self.canvas = None
|
|
|
| def _ensure_charts(self):
|
| if self.canvas is None:
|
| import matplotlib
|
| matplotlib.use("TkAgg")
|
| from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
|
| from matplotlib.figure import Figure
|
| self.fig = Figure(figsize=(10, 7), dpi=100, facecolor=BG)
|
| self.canvas = FigureCanvasTkAgg(self.fig, master=self.charts_tab)
|
| self.canvas.get_tk_widget().pack(fill="both", expand=True)
|
|
|
| def _build_settings(self):
|
| f = ttk.Frame(self.tabs, padding=20)
|
| self.tabs.add(f, text=" Settings ")
|
| grid = ttk.Frame(f)
|
| grid.pack(anchor="w")
|
| ttk.Label(grid, text="Daily goal (hours)").grid(row=0, column=0, sticky="w", pady=6)
|
| sp, _ = self._spin(grid, "goal_hours", 4, 0.5, 24, cast=float, increment=0.5, after=lambda v: self.refresh())
|
| sp.grid(row=0, column=1, padx=14)
|
| ttk.Label(grid, text="Auto-pause after idle (minutes, 0 = never)").grid(row=1, column=0, sticky="w", pady=6)
|
| sp, _ = self._spin(grid, "idle_minutes", 5, 0, 240)
|
| sp.grid(row=1, column=1, padx=14)
|
| ttk.Checkbutton(f, text="Start with Windows", variable=self.app.autostart_var,
|
| command=self.app.toggle_autostart).pack(anchor="w", pady=(10, 2))
|
| ttk.Checkbutton(f, text="Show the corner icon (drag it anywhere; right-click > Reset icon position)",
|
| variable=self.app.overlay_var,
|
| command=self.app.apply_overlay_visibility).pack(anchor="w", pady=(2, 10))
|
| ttk.Label(f, text=f"Data file: {self.app.db_path}", style="Muted.TLabel").pack(anchor="w", pady=4)
|
| ttk.Label(f, text="Closing this window keeps Focus Tracker running in the system tray (next to the clock).",
|
| style="Muted.TLabel").pack(anchor="w")
|
| ttk.Button(f, text="Quit Focus Tracker", style="Danger.TButton", command=self.app.quit).pack(anchor="w", pady=18)
|
|
|
|
|
| def _project_chosen(self, _=None):
|
| name = self.project_var.get().strip()
|
| if name and name != self.app.project:
|
| self.app.set_project(name)
|
| self.refresh()
|
|
|
| def add_project(self):
|
| name = simpledialog.askstring("Add project", "Project name:", parent=self.win)
|
| if name and name.strip():
|
| self.app.db.add_project(name.strip())
|
| self.refresh()
|
|
|
| @staticmethod
|
| def _selected(tree):
|
| sel = tree.selection()
|
| return sel[0] if sel else None
|
|
|
| def rename_project(self):
|
| old = self._selected(self.proj_tree)
|
| if not old:
|
| return
|
| new = simpledialog.askstring("Rename project", f"New name for '{old}':", initialvalue=old, parent=self.win)
|
| if new and new.strip() and new.strip() != old:
|
| new = new.strip()
|
| self.app.db.rename_project(old, new)
|
| if self.app.project == old:
|
| self.app.project = new
|
| self.app.db.set("project", new)
|
| self.refresh()
|
|
|
| def delete_project(self):
|
| name = self._selected(self.proj_tree)
|
| if not name:
|
| return
|
| n = self.app.db.con.execute("SELECT COUNT(*) FROM sessions WHERE project=?", (name,)).fetchone()[0]
|
| if not messagebox.askyesno("Delete project", f"Delete '{name}' and its {n} recorded session(s)?\n"
|
| "This cannot be undone.", parent=self.win):
|
| return
|
| if self.app.session and self.app.project == name:
|
| self.app.pause()
|
| self.app.db.delete_project(name)
|
| if self.app.project == name:
|
| self.app.project = ""
|
| self.app.db.set("project", "")
|
| self.app.refresh_today()
|
| self.refresh()
|
|
|
|
|
| def _selected_session(self):
|
| sid = self._selected(self.sess_tree)
|
| if not sid:
|
| messagebox.showinfo("Sessions", "Select a session in the list first.", parent=self.win)
|
| return None
|
| if self.app.session and int(sid) == self.app.session[0]:
|
| messagebox.showinfo("Sessions", "Pause the running session first.", parent=self.win)
|
| return None
|
| return next(s for s in self.app.db.sessions(int(time.time())) if s[0] == int(sid))
|
|
|
| def add_session(self):
|
| dlg = SessionDialog(self.win, self.app.db.projects())
|
| if dlg.result:
|
| self.app.db.add_session(*dlg.result)
|
| self._changed()
|
|
|
| def edit_session(self):
|
| session = self._selected_session()
|
| if not session:
|
| return
|
| dlg = SessionDialog(self.win, self.app.db.projects(), session)
|
| if dlg.result:
|
| self.app.db.update_session(session[0], *dlg.result)
|
| self._changed()
|
|
|
| def delete_session(self):
|
| session = self._selected_session()
|
| if session and messagebox.askyesno("Delete session", "Delete the selected session?", parent=self.win):
|
| self.app.db.delete_session(session[0])
|
| self._changed()
|
|
|
| def _changed(self):
|
| self.app.refresh_today()
|
| self.refresh()
|
|
|
|
|
| def export_csv(self):
|
| path = filedialog.asksaveasfilename(parent=self.win, defaultextension=".csv",
|
| initialfile="focus_sessions.csv", filetypes=[("CSV", "*.csv")])
|
| if not path:
|
| return
|
| with open(path, "w", newline="", encoding="utf-8") as f:
|
| w = csv.writer(f)
|
| w.writerow(CSV_COLUMNS)
|
| for _, project, start, end, plan in self.app.db.sessions(int(time.time())):
|
| w.writerow([fmt_dt(start), fmt_dt(end), round((end - start) / 60, 1), plan or "",
|
| int(plan_met(start, end, plan)), project])
|
| messagebox.showinfo("Export", f"Exported to\n{path}", parent=self.win)
|
|
|
| def import_csv(self):
|
| path = filedialog.askopenfilename(parent=self.win, filetypes=[("CSV", "*.csv"), ("All files", "*.*")])
|
| if not path:
|
| return
|
| db, added, skipped, bad = self.app.db, 0, 0, []
|
| try:
|
| with open(path, newline="", encoding="utf-8-sig") as f:
|
| reader = csv.DictReader(f)
|
| if not {"start", "end", "project"} <= set(reader.fieldnames or []):
|
| raise ValueError("The file needs the columns: start, end, project "
|
| "(optional: plan_minutes). Use a file made by Export CSV.")
|
| for n, row in enumerate(reader, start=2):
|
| try:
|
| project = (row["project"] or "").strip()
|
| start, end = parse_dt(row["start"]), parse_dt(row["end"])
|
| plan = int(float(row["plan_minutes"])) if (row.get("plan_minutes") or "").strip() else None
|
| if not project or end - start < MIN_SESSION_S:
|
| raise ValueError("empty project or end before start")
|
| except (ValueError, TypeError, KeyError) as e:
|
| bad.append(f"line {n}: {e}")
|
| continue
|
| if db.has_session(project, start, end):
|
| skipped += 1
|
| else:
|
| db.add_session(project, start, end, plan)
|
| added += 1
|
| except (OSError, ValueError, csv.Error) as e:
|
| messagebox.showerror("Import", str(e), parent=self.win)
|
| return
|
| msg = f"Imported {added} session(s), skipped {skipped} duplicate(s)."
|
| if bad:
|
| msg += f"\n{len(bad)} row(s) ignored:\n" + "\n".join(bad[:8]) + ("\n..." if len(bad) > 8 else "")
|
| messagebox.showinfo("Import", msg, parent=self.win)
|
| self._changed()
|
|
|
|
|
| def _live(self):
|
| a = self.app
|
| if self.visible():
|
| c = self.ring
|
| if a.session:
|
| el = time.time() - a.session[1]
|
| plan_s = a.session[2] * 60
|
| color, frac = plan_color(el, plan_s), min(1.0, el / plan_s)
|
| c.itemconfig(self.r_time, text=mmss(el))
|
| c.itemconfig(self.r_sub, text=f"of {a.session[2]} min" if el < plan_s else "plan reached!", fill=color)
|
| self.r_status.config(text=f"Focusing on {a.project}")
|
| self.btn.config(text="Pause", bg=ORANGE, activebackground="#e08a00")
|
| else:
|
| color, frac = GRAY, 0.0
|
| c.itemconfig(self.r_time, text="00:00")
|
| c.itemconfig(self.r_sub, text=f"plan {a.plan_min} min", fill=GRAY)
|
| self.r_status.config(text="Paused (idle)" if a.idle_paused else "Ready")
|
| self.btn.config(text="Start", bg=GREEN, activebackground="#2aa84f")
|
| c.itemconfig(self.r_arc, outline=color, extent=-min(359.9, 360 * frac))
|
| c.itemconfig(self.r_time, fill="white")
|
| self.win.after(1000, self._live)
|
|
|
|
|
| def refresh(self):
|
| if not self.visible():
|
| return
|
| a = self.app
|
| now = int(time.time())
|
| sessions = a.db.sessions(now)
|
| today = date.today()
|
| days = RANGES[self.range_var.get()]
|
| first = today - timedelta(days=days - 1) if days else (
|
| datetime.fromtimestamp(sessions[0][2]).date() if sessions else today)
|
| since = datetime.combine(first, datetime.min.time())
|
|
|
| info = defaultdict(lambda: {"secs": 0.0, "n": 0, "met": 0, "proj": defaultdict(float)})
|
| for _, _project, start, end, plan in sessions:
|
| d = info[datetime.fromtimestamp(start).date()]
|
| d["n"] += 1
|
| d["met"] += plan_met(start, end, plan)
|
| segs = list(split_hours(sessions))
|
| for hour, secs, project in segs:
|
| d = info[hour.date()]
|
| d["secs"] += secs
|
| d["proj"][project] += secs
|
|
|
| self._refresh_home(sessions, info, today)
|
| self._refresh_daily(info, first, today)
|
| self._refresh_projects(sessions)
|
| if self.tabs.select() == str(self.charts_tab):
|
| self._draw_charts(info, [s for s in segs if s[0] >= since], first, today)
|
|
|
| def _refresh_home(self, sessions, info, today):
|
| a = self.app
|
| projects = a.db.projects()
|
| self.project_box.config(values=projects)
|
| self.filter_box.config(values=["All projects"] + projects)
|
| if self.filter_var.get() not in self.filter_box.cget("values"):
|
| self.filter_var.set("All projects")
|
| if self.win.focus_get() is not self.project_box:
|
| self.project_var.set(a.project)
|
| if self.win.focus_get() is not self.plan_spin:
|
| self.plan_var.set(str(a.plan_min))
|
|
|
| d = today if info[today]["secs"] else today - timedelta(days=1)
|
| streak = 0
|
| while info[d]["secs"] > 0:
|
| streak += 1
|
| d -= timedelta(days=1)
|
| week_start = today - timedelta(days=today.weekday())
|
| week = sum(v["secs"] for k, v in info.items() if k >= week_start)
|
| goal = float(a.db.get("goal_hours", 4)) * 3600
|
| t = info[today]
|
| self.s_today[0].config(text=fmt_hm(t["secs"]))
|
| self.s_today[1].config(text=f"{min(100, int(100 * t['secs'] / goal))}% of {fmt_hm(goal)} goal")
|
| self.s_week[0].config(text=fmt_hm(week))
|
| self.s_week[1].config(text=f"since {week_start.strftime('%b %d')}")
|
| self.s_streak[0].config(text=f"{streak} day{'s' if streak != 1 else ''}")
|
| self.s_streak[1].config(text="in a row")
|
| self.s_plans[0].config(text=f"{t['met']} / {t['n']}")
|
| self.s_plans[1].config(text="reached the plan")
|
|
|
| days = SHOW[self.show_var.get()]
|
| since = datetime.combine(today - timedelta(days=days - 1), datetime.min.time()).timestamp() if days else 0
|
| wanted = self.filter_var.get()
|
| rows = []
|
| for sid, project, start, end, plan in reversed(sessions):
|
| if end < since or (wanted != "All projects" and project != wanted):
|
| continue
|
| s, e = datetime.fromtimestamp(start), datetime.fromtimestamp(end)
|
| running = a.session is not None and sid == a.session[0]
|
| rows.append((str(sid), (s.strftime("%Y-%m-%d"), s.strftime("%H:%M:%S"),
|
| "running" if running else e.strftime("%H:%M:%S"), fmt_hm(end - start),
|
| plan_text(start, end, plan), project),
|
| ("met",) if plan_met(start, end, plan) else ()))
|
| fill(self.sess_tree, rows)
|
|
|
| def _refresh_daily(self, info, first, today):
|
| rows = []
|
| for i in range((today - first).days + 1):
|
| d = today - timedelta(days=i)
|
| v = info.get(d)
|
| if not v or not v["secs"]:
|
| continue
|
| projects = ", ".join(f"{p} {fmt_hm(s)}" for p, s in sorted(v["proj"].items(), key=lambda kv: -kv[1]))
|
| rows.append((d.isoformat(), (d.isoformat(), WEEKDAYS[d.weekday()], fmt_hm(v["secs"]),
|
| v["n"], f"{v['met']}/{v['n']}", projects)))
|
| fill(self.daily_tree, rows)
|
|
|
| def _refresh_projects(self, sessions):
|
| total, count, last = defaultdict(float), defaultdict(int), {}
|
| for _, project, start, end, _ in sessions:
|
| total[project] += end - start
|
| count[project] += 1
|
| last[project] = max(last.get(project, 0), start)
|
| rows = []
|
| for p in self.app.db.projects():
|
| when = datetime.fromtimestamp(last[p]).strftime("%Y-%m-%d") if p in last else "-"
|
| rows.append((p, (p, fmt_hm(total[p]), count[p], when)))
|
| fill(self.proj_tree, rows)
|
|
|
| def _draw_charts(self, info, segs, first, today):
|
| import matplotlib.dates as mdates
|
| import numpy as np
|
| self._ensure_charts()
|
| per_project = defaultdict(float)
|
| per_week = defaultdict(float)
|
| heat = np.zeros((7, 24))
|
| for hour, secs, project in segs:
|
| per_project[project] += secs
|
| heat[hour.weekday(), hour.hour] += secs / 3600
|
| per_week[hour.date() - timedelta(days=hour.weekday())] += secs
|
|
|
| fig = self.fig
|
| fig.clear()
|
| goal = float(self.app.db.get("goal_hours", 4))
|
| ax1, ax2, ax3, ax4 = fig.subplots(2, 2).flat
|
| for ax in (ax1, ax2, ax3, ax4):
|
| ax.set_facecolor(CARD)
|
|
|
| days = [first + timedelta(days=i) for i in range((today - first).days + 1)][-365:]
|
| hours = [info[d]["secs"] / 3600 if d in info else 0 for d in days]
|
| ax1.bar(days, hours, color=[GREEN if h >= goal else ACCENT for h in hours], width=0.8)
|
| ax1.axhline(goal, color=RED, lw=1, ls="--", label=f"Goal {goal:g}h")
|
| ax1.set_title("Hours per day")
|
| ax1.set_ylabel("hours")
|
| ax1.legend(loc="upper left", frameon=False)
|
| loc = mdates.AutoDateLocator()
|
| ax1.xaxis.set_major_locator(loc)
|
| ax1.xaxis.set_major_formatter(mdates.ConciseDateFormatter(loc))
|
|
|
| items = sorted(per_project.items(), key=lambda kv: kv[1])[-10:]
|
| ax2.barh([k for k, _ in items], [v / 3600 for _, v in items], color=ACCENT)
|
| ax2.set_title("Hours per project")
|
| ax2.set_xlabel("hours")
|
| for i, (_, v) in enumerate(items):
|
| ax2.text(v / 3600, i, f" {fmt_hm(v)}", va="center", fontsize=8)
|
| ax2.margins(x=0.25)
|
|
|
| im = ax3.imshow(heat, aspect="auto", cmap="Blues")
|
| ax3.set_title("When you focus (hours)")
|
| ax3.set_yticks(range(7), WEEKDAYS)
|
| ax3.set_xticks(range(0, 24, 3), [f"{h:02d}:00" for h in range(0, 24, 3)])
|
| fig.colorbar(im, ax=ax3, pad=0.02).set_label("hours")
|
|
|
| weeks = sorted(per_week)[-12:]
|
| ax4.bar([w.strftime("%b %d") for w in weeks], [per_week[w] / 3600 for w in weeks], color=ACCENT)
|
| ax4.set_title("Hours per week")
|
| ax4.set_ylabel("hours")
|
| ax4.tick_params(axis="x", rotation=45)
|
|
|
| for ax in (ax1, ax2, ax4):
|
| ax.spines[["top", "right"]].set_visible(False)
|
| fig.tight_layout()
|
| self.canvas.draw_idle()
|
|
|
