270 lines
8.7 KiB
Python
Executable file
270 lines
8.7 KiB
Python
Executable file
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*-
|
|
|
|
import argparse
|
|
from signal import signal, SIGINT
|
|
import sys
|
|
from time import sleep
|
|
from os.path import expanduser, join
|
|
from datetime import datetime, timedelta
|
|
|
|
TIME_FILE = join(expanduser("~"), "timekeeping.csv")
|
|
TODAY_FILE = join(expanduser("~"), ".timekeeping")
|
|
|
|
is_on_break = False
|
|
today_fields = []
|
|
start_time = datetime.now()
|
|
|
|
|
|
def die(*args):
|
|
print("Error: {}".format(*args), file=sys.stderr)
|
|
sys.exit(1)
|
|
|
|
|
|
def log(*args):
|
|
print(*args, file=sys.stderr)
|
|
|
|
|
|
def signal_handler(signal, frame):
|
|
global today_fields
|
|
now = datetime.now()
|
|
hour = now.strftime("%H:%M")
|
|
if not is_on_break:
|
|
sys.exit(0)
|
|
else:
|
|
break_time = now - start_time
|
|
log("\nBreak ended at {} and lasted {}".format(
|
|
hour, td_format(break_time)))
|
|
today_fields.append(start_time.strftime("%H:%M"))
|
|
today_fields.append(hour)
|
|
with open(TODAY_FILE, "w") as f:
|
|
f.write(",".join(today_fields))
|
|
sys.exit(0)
|
|
|
|
|
|
def td_format(td):
|
|
hours, remainder = divmod(td.total_seconds(), 3600)
|
|
minutes, seconds = divmod(remainder, 60)
|
|
|
|
return '{:d}:{:02d}'.format(int(hours), int(minutes))
|
|
|
|
|
|
def get_today_fields():
|
|
try:
|
|
with open(TODAY_FILE, "r") as f:
|
|
line_count = 0
|
|
for line in f:
|
|
line_count += 1
|
|
if line_count > 1:
|
|
log("Warning: incomplete day leftover in {}".format(TODAY_FILE))
|
|
if line.startswith(start_time.strftime("%Y-%m-%d")):
|
|
return line.strip().split(",")
|
|
except FileNotFoundError:
|
|
return []
|
|
return []
|
|
|
|
|
|
def work(args):
|
|
total_delta = timedelta()
|
|
month_delta = timedelta()
|
|
count = 0
|
|
month_count = 0
|
|
with open(TIME_FILE, "r") as f:
|
|
for line in f:
|
|
fields = line.strip().split(",", 5)
|
|
date = datetime.strptime(fields[0], "%Y-%m-%d")
|
|
t = datetime.strptime(fields[4], "%H:%M")
|
|
delta = timedelta(hours=t.hour, minutes=t.minute)
|
|
if date.month == start_time.month:
|
|
month_delta += delta
|
|
month_count += 1
|
|
total_delta += delta
|
|
count += 1
|
|
eight_h = timedelta(hours=8) * count
|
|
mean_time = total_delta / count if count > 0 else total_delta
|
|
minutes = total_delta - eight_h
|
|
month_mean_time = month_delta / month_count if month_count > 0 else month_delta
|
|
month_min = month_delta - timedelta(hours=(8 * month_count))
|
|
print("stats: {}, {}".format(
|
|
td_format(mean_time),
|
|
td_format(minutes)))
|
|
print("month stats: {}, {}".format(
|
|
td_format(month_mean_time),
|
|
td_format(month_min)))
|
|
|
|
# Try to calculate remaining time
|
|
fields = get_today_fields()
|
|
hour = start_time.strftime("%H:%M")
|
|
if not fields:
|
|
print("No work ongoing")
|
|
return
|
|
fields.append(hour)
|
|
# Test for even number of timestamp (but fields[0] is the date)
|
|
if len(fields) < 3:
|
|
die("not enough fields in {}".format(TODAY_FILE))
|
|
elif len(fields) % 2 == 0:
|
|
# Break in progress
|
|
log("Break in progress")
|
|
return
|
|
begin_time = None
|
|
worked_time = timedelta()
|
|
for field in fields[1:]:
|
|
try:
|
|
if begin_time is None:
|
|
begin_time = datetime.strptime(field, "%H:%M")
|
|
else:
|
|
end_time = datetime.strptime(field, "%H:%M")
|
|
worked_time += end_time - begin_time
|
|
begin_time = None
|
|
except ValueError:
|
|
die("couldn't parse field '{}' in {}".format(
|
|
field, TODAY_FILE))
|
|
day_start = datetime.strptime(fields[1], "%H:%M")
|
|
day_end = datetime.strptime(fields[-1], "%H:%M")
|
|
total_time = day_end - day_start
|
|
break_time = total_time - worked_time
|
|
day_end_estimation = day_start + timedelta(hours=8) + break_time
|
|
print("Worked {} already today. Estimated leave at {}".format(
|
|
td_format(worked_time),
|
|
day_end_estimation.strftime("%H:%M")))
|
|
|
|
|
|
|
|
def work_start(args):
|
|
fields = get_today_fields()
|
|
try:
|
|
hour = datetime.strptime(args.time, "%H:%M")
|
|
except ValueError:
|
|
die("Error: {} is not a valid time".format(args.time))
|
|
if fields:
|
|
die("You already started working")
|
|
with open(TODAY_FILE, "a") as f:
|
|
f.write("{},{}".format(
|
|
start_time.strftime("%Y-%m-%d"),
|
|
hour.strftime("%H:%M")))
|
|
log("Started working at {}".format(hour.strftime("%H:%M")))
|
|
|
|
|
|
def work_pause(args):
|
|
global is_on_break
|
|
global today_fields
|
|
is_on_break = True
|
|
today_fields = get_today_fields()
|
|
hour = start_time.strftime("%H:%M")
|
|
if not today_fields:
|
|
die("no work to take a break from")
|
|
log("Taking a break at {}".format(hour))
|
|
# Wait to be stopped by a Ctrl-C
|
|
sleep(999999)
|
|
|
|
|
|
def work_end(args):
|
|
fields = get_today_fields()
|
|
hour = start_time.strftime("%H:%M")
|
|
if not fields:
|
|
die("Why try to leave when you haven't even started")
|
|
fields.append(hour)
|
|
# Test for even number of timestamp (but fields[0] is the date)
|
|
if len(fields) < 3:
|
|
die("not enough fields in {}".format(TODAY_FILE))
|
|
elif len(fields) % 2 == 0:
|
|
die("odd number of timestamps in {}".format(TODAY_FILE))
|
|
begin_time = None
|
|
worked_time = timedelta()
|
|
for field in fields[1:]:
|
|
try:
|
|
if begin_time is None:
|
|
begin_time = datetime.strptime(field, "%H:%M")
|
|
else:
|
|
end_time = datetime.strptime(field, "%H:%M")
|
|
worked_time += end_time - begin_time
|
|
begin_time = None
|
|
except ValueError:
|
|
die("couldn't parse field '{}' in {}".format(
|
|
field, TODAY_FILE))
|
|
day_start = datetime.strptime(fields[1], "%H:%M")
|
|
day_end = datetime.strptime(fields[-1], "%H:%M")
|
|
total_time = day_end - day_start
|
|
break_time = total_time - worked_time
|
|
with open(TIME_FILE, "a") as f:
|
|
f.write("{},{},{},{},{},{}\n".format(
|
|
fields[0],
|
|
day_start.strftime("%H:%M"),
|
|
start_time.strftime("%H:%M"),
|
|
td_format(break_time),
|
|
td_format(worked_time),
|
|
args.description))
|
|
# Erase TODAY_FILE
|
|
with open(TODAY_FILE, "w") as f:
|
|
f.write("")
|
|
f.flush()
|
|
log("Finished working at {} after working {}".format(
|
|
hour, td_format(worked_time)))
|
|
|
|
|
|
def work_export(args):
|
|
print("export")
|
|
|
|
|
|
def work_parse(args):
|
|
new_lines = []
|
|
try:
|
|
with open(args.file, "r") as f:
|
|
for line in f:
|
|
fields = line.split(",")
|
|
if len(fields) < 6:
|
|
log("Record: '{}' hasn't got enough fields ({})".format(line, len(fields)))
|
|
continue
|
|
morning = datetime.strptime(fields[1], "%H:%M")
|
|
break_start = datetime.strptime(fields[2], "%H:%M")
|
|
break_end = datetime.strptime(fields[3], "%H:%M")
|
|
evening = datetime.strptime(fields[4], "%H:%M")
|
|
break_time = break_end - break_start
|
|
full_day = evening - morning
|
|
work_day = full_day - break_time
|
|
new_lines.append('{},{},{},{},{},{}'.format(
|
|
fields[0],
|
|
morning.strftime("%H:%M"),
|
|
evening.strftime("%H:%M"),
|
|
td_format(break_time),
|
|
td_format(work_day),
|
|
"".join(fields[5:]).strip()))
|
|
except FileNotFoundError:
|
|
die("file not found: {}".format(args.file))
|
|
# TODO do sanity checking, like if a day already exists
|
|
with open(TIME_FILE, "a") as f:
|
|
for line in new_lines:
|
|
f.write("{}\n".format(line))
|
|
log("Written {} new entries to {}".format(len(new_lines), TIME_FILE))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
# Handle Ctrl-C
|
|
signal(SIGINT, signal_handler)
|
|
|
|
parser = argparse.ArgumentParser()
|
|
parser.set_defaults(func=work)
|
|
commands = parser.add_subparsers(dest="command")
|
|
|
|
start_parser = commands.add_parser("start")
|
|
pause_parser = commands.add_parser("pause")
|
|
end_parser = commands.add_parser("end")
|
|
export_parser = commands.add_parser("export")
|
|
parse_parser = commands.add_parser("parse")
|
|
|
|
start_parser.set_defaults(func=work_start)
|
|
start_parser.add_argument("time", nargs="?", default=datetime.now().strftime("%H:%M"))
|
|
pause_parser.set_defaults(func=work_pause)
|
|
end_parser.set_defaults(func=work_end)
|
|
end_parser.add_argument("description")
|
|
export_parser.set_defaults(func=work_export)
|
|
parse_parser.set_defaults(func=work_parse)
|
|
parse_parser.add_argument("file")
|
|
|
|
args = parser.parse_args()
|
|
args.func(args)
|
|
|
|
#now = datetime.now()
|
|
#with open(TIME_FILE, "r") as f:
|
|
# for line in f:
|
|
# print(line.strip())
|