Вообще мне кажется с таким справится ща попробуем
#!/usr/bin/env python3
"""
Daily Routine Tracker - A Tkinter GUI application for tracking daily repetitive tasks.
"""

import tkinter as tk
from tkinter import messagebox
from datetime import datetime
from pathlib import Path
import yaml
import os

class RoutineDiary:
def __init__(self, root):
self.root = root
self.root.title("Daily Routine Tracker")
self.root.geometry("400x600")

self.tasks_file = Path("tasks.txt")
self.diary_file = Path("diary.yaml")

self.tasks = []
self.today_clicks = {} # {task_name: [datetime, datetime, ...]}
self.buttons = {} # {task_name: button_widget}

self.load_tasks()
self.load_today_clicks()
self.create_gui()

def load_tasks(self):
"""Load tasks from tasks.txt file."""
if not self.tasks_file.exists():
messagebox.showerror("Error", "tasks.txt file not found!")
self.root.destroy()
return

with open(self.tasks_file, "r", encoding="utf-8") as f:
self.tasks = [line.strip() for line in f if line.strip()]

self.tasks = sorted(self.tasks, key=str.lower)

def load_diary(self):
"""Load the entire diary from diary.yaml."""
if not self.diary_file.exists():
return []

with open(self.diary_file, "r", encoding="utf-8") as f:
content = f.read()
if not content.strip():
return []
try:
data = yaml.safe_load(content)
return data if data else []
except yaml.YAMLError:
return []

def load_today_clicks(self):
"""Load today's clicks from diary.yaml."""
today_str = datetime.now().strftime("%Y-%m-%d")
self.today_clicks = {}

diary = self.load_diary()
if not diary:
return

# Find today's section in the diary
i = 0
while i < len(diary):
if diary == today_str:
# Found today's date, load all tasks until next date or end
i += 1
while i < len(diary):
item = diary
if isinstance(item, dict):
for task_name, timestamps in item.items():
if isinstance(timestamps, list):
self.today_clicks[task_name] = [
datetime.strptime(ts, "%Y-%m-%d %H:%M")
for ts in timestamps
]
i += 1
elif isinstance(item, str) and len(item) == 10 and item[4] == '-':
# Next date found
break
else:
i += 1
break
i += 1

def save_diary(self):
"""Save click to diary.yaml."""
today_str = datetime.now().strftime("%Y-%m-%d")
diary = self.load_diary()

# Find and remove today's section if it exists
new_diary = []
i = 0
while i < len(diary):
if diary == today_str:
# Skip today's date and all its tasks
i += 1
while i < len(diary):
item = diary
if isinstance(item, str) and len(item) == 10 and item[4] == '-':
# Next date found
break
i += 1
else:
new_diary.append(diary)
i += 1

# Add today's section with updated data
if self.today_clicks:
new_diary.append(today_str)
for task_name in sorted(self.today_clicks.keys(), key=str.lower):
timestamps = [dt.strftime("%Y-%m-%d %H:%M") for dt in self.today_clicks[task_name]]
new_diary.append({task_name: timestamps})

# Write to file
with open(self.diary_file, "w", encoding="utf-8") as f:
yaml.dump(new_diary, f, default_flow_style=None, allow_unicode=True, sort_keys=False)

def create_gui(self):
"""Create the main GUI."""
# Title label
title_label = tk.Label(
self.root,
text="Daily Routines",
font=("Arial", 16, "bold"),
pady=10
)
title_label.pack()

# Date label
today_str = datetime.now().strftime("%Y-%m-%d")
date_label = tk.Label(
self.root,
text=f"Today: {today_str}",
font=("Arial", 12),
pady=5
)
date_label.pack()

# Scrollable frame for buttons
container = tk.Frame(self.root)
container.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

canvas = tk.Canvas(container)
scrollbar = tk.Scrollbar(container, orient="vertical", command=canvas.yview)
self.scrollable_frame = tk.Frame(canvas)

self.scrollable_frame.bind(
"<Configure>",
lambda e: canvas.configure(scrollregion=canvas.bbox("all"))
)

canvas.create_window((0, 0), window=self.scrollable_frame, anchor="nw")
canvas.configure(yscrollcommand=scrollbar.set)

# Bind mouse wheel scrolling
def on_mousewheel(event):
canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")

def on_mousewheel_linux(event):
if event.num == 4:
canvas.yview_scroll(-1, "units")
elif event.num == 5:
canvas.yview_scroll(1, "units")

canvas.bind_all("<MouseWheel>", on_mousewheel)
canvas.bind_all("<Button-4>", on_mousewheel_linux)
canvas.bind_all("<Button-5>", on_mousewheel_linux)

scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

self.canvas = canvas
self.update_buttons()

def get_sorted_tasks(self):
"""Get tasks sorted according to the rules."""
not_clicked = []
clicked = []

for task in self.tasks:
if task in self.today_clicks and len(self.today_clicks[task]) > 0:
clicked.append(task)
else:
not_clicked.append(task)

not_clicked.sort(key=str.lower)
clicked.sort(key=str.lower)

return not_clicked + clicked

def update_buttons(self):
"""Update the button display."""
# Clear existing buttons
for widget in self.scrollable_frame.winfo_children():
widget.destroy()

self.buttons = {}
sorted_tasks = self.get_sorted_tasks()

for task in sorted_tasks:
click_count = len(self.today_clicks.get(task, []))

if click_count > 0:
button_text = f"{task} ({click_count})"
bg_color = "#90EE90" # Light green for clicked
else:
button_text = task
bg_color = "#F0F0F0" # Default gray

btn = tk.Button(
self.scrollable_frame,
text=button_text,
font=("Arial", 11),
bg=bg_color,
activebackground="#ADD8E6",
anchor="w",
padx=10,
pady=5,
command=lambda t=task: self.on_task_click(t)
)
btn.pack(fill=tk.X, pady=2)
self.buttons[task] = btn

# Update scroll region
self.scrollable_frame.update_idletasks()
self.canvas.configure(scrollregion=self.canvas.bbox("all"))

def on_task_click(self, task_name):
"""Handle task button click."""
now = datetime.now()
# Round to minute (remove seconds/microseconds for cleaner timestamps)
now = now.replace(second=0, microsecond=0)

if task_name not in self.today_clicks:
self.today_clicks[task_name] = []

self.today_clicks[task_name].append(now)

self.save_diary()
self.update_buttons()

def main():
root = tk.Tk()
app = RoutineDiary(root)
root.mainloop()

if __name__ == "__main__":
main()

>>30627
Лол.

import tkinter as tk
from tkinter import messagebox
import yaml
import os
from datetime import datetime
from collections import defaultdict

class RoutineDiaryApp:
def __init__(self, root):
self.root = root
self.root.title("Routine Diary")
self.root.geometry("600x500")

self.tasks_file = "tasks.txt"
self.diary_file = "diary.yaml"

# Данные
self.all_tasks = [] # Все задачи из файла
self.today = datetime.now().strftime("%Y-%m-%d")
self.today_clicks = defaultdict(int) # Счетчики кликов на сегодня
self.clicked_tasks = set() # Задачи, нажатые сегодня

# Загрузка данных
self.load_tasks()
self.load_diary()

# GUI элементы
self.create_widgets()
self.update_buttons()

def load_tasks(self):
"""Загрузка списка задач из файла"""
try:
if os.path.exists(self.tasks_file):
with open(self.tasks_file, 'r', encoding='utf-8') as f:
self.all_tasks = sorted([line.strip() for line in f if line.strip()])
else:
# Создаем пример файла, если его нет
with open(self.tasks_file, 'w', encoding='utf-8') as f:
f.write("eat shizaprotective tablet\ntroll on dvach\nwipe ass after taking shit\n")
self.all_tasks = ["eat shizaprotective tablet", "troll on dvach", "wipe ass after taking shit"]
except Exception as e:
messagebox.showerror("Error", f"Failed to load tasks: {e}")
self.all_tasks = []

def load_diary(self):
"""Загрузка истории из YAML файла"""
try:
if os.path.exists(self.diary_file):
with open(self.diary_file, 'r', encoding='utf-8') as f:
diary_data = yaml.safe_load(f) or []

# Ищем записи за сегодня
for day_entry in diary_data:
if isinstance(day_entry, dict) and self.today in day_entry:
today_data = day_entry[self.today]
for task, timestamps in today_data.items():
if isinstance(timestamps, list):
self.today_clicks[task] = len(timestamps)
if timestamps:
self.clicked_tasks.add(task)
break
except Exception as e:
print(f"Warning: Could not load diary: {e}")
# Создаем пустой файл
self.save_to_diary([])

def save_to_diary(self, data):
"""Сохранение данных в YAML файл"""
try:
with open(self.diary_file, 'w', encoding='utf-8') as f:
yaml.dump(data, f, allow_unicode=True, default_flow_style=False)
except Exception as e:
messagebox.showerror("Error", f"Failed to save diary: {e}")

def create_widgets(self):
"""Создание элементов интерфейса"""
# Фрейм для кнопок
self.button_frame = tk.Frame(self.root)
self.button_frame.pack(fill=tk.BOTH, expand=True, padx=10, pady=10)

# Scrollbar для кнопок
scrollbar = tk.Scrollbar(self.button_frame)
scrollbar.pack(side=tk.RIGHT, fill=tk.Y)

# Canvas для скроллирования кнопок
self.canvas = tk.Canvas(self.button_frame, yscrollcommand=scrollbar.set)
self.canvas.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)

scrollbar.config(command=self.canvas.yview)

# Фрейм для кнопок внутри canvas
self.inner_frame = tk.Frame(self.canvas)
self.canvas_window = self.canvas.create_window((0, 0), window=self.inner_frame, anchor=tk.NW)

# Привязка событий для скроллинга
self.inner_frame.bind("<Configure>", self.on_frame_configure)
self.canvas.bind("<Configure>", self.on_canvas_configure)

# Метка с текущей датой
self.date_label = tk.Label(self.root, text=f"Today: {self.today}", font=("Arial", 12, "bold"))
self.date_label.pack(pady=5)

def on_frame_configure(self, event):
"""Обновление scrollregion при изменении размера фрейма"""
self.canvas.configure(scrollregion=self.canvas.bbox("all"))

def on_canvas_configure(self, event):
"""Обновление ширины внутреннего фрейма при изменении размера canvas"""
self.canvas.itemconfig(self.canvas_window, width=event.width)

def update_buttons(self):
"""Обновление отображения кнопок"""
# Очистка старых кнопок
for widget in self.inner_frame.winfo_children():
widget.destroy()

# Разделение задач на нажатые и ненажатые
unclicked = sorted([t for t in self.all_tasks if t not in self.clicked_tasks])
clicked = sorted([t for t in self.all_tasks if t in self.clicked_tasks])

# Создание кнопок для ненажатых задач
for task in unclicked:
btn = tk.Button(self.inner_frame, text=task,
command=lambda t=task: self.on_task_click(t),
bg="lightgray", height=2, width=40)
btn.pack(pady=2, padx=5, fill=tk.X)

# Создание кнопок для нажатых задач (с количеством кликов)
for task in clicked:
count = self.today_clicks[task]
btn_text = f"{task} ({count})"
btn = tk.Button(self.inner_frame, text=btn_text,
command=lambda t=task: self.on_task_click(t),
bg="lightgreen", height=2, width=40)
btn.pack(pady=2, padx=5, fill=tk.X)

def on_task_click(self, task):
"""Обработка клика по кнопке задачи"""
try:
current_time = datetime.now()
timestamp = current_time.strftime("%Y-%m-%d %H:%M")

# Обновление счетчиков
self.today_clicks[task] += 1
self.clicked_tasks.add(task)

# Загрузка существующего дневника
diary_data = []
if os.path.exists(self.diary_file):
with open(self.diary_file, 'r', encoding='utf-8') as f:
diary_data = yaml.safe_load(f) or []

# Поиск или создание записи за сегодня
today_entry = None
for entry in diary_data:
if isinstance(entry, dict) and self.today in entry:
today_entry = entry
break

if not today_entry:
today_entry = {self.today: {}}
diary_data.append(today_entry)

# Добавление timestamp
if task not in today_entry[self.today]:
today_entry[self.today][task] = []

today_entry[self.today][task].append(timestamp)

# Сохранение
self.save_to_diary(diary_data)

# Обновление интерфейса
self.update_buttons()

except Exception as e:
messagebox.showerror("Error", f"Failed to log task: {e}")

def main():
root = tk.Tk()
app = RoutineDiaryApp(root)
root.mainloop()

if __name__ == "__main__":
main()