if k in VALID_RECORD_SORT_KEYS:

return k

print("Sort key must be one of: %s" % str(VALID_RECORD_SORT_KEYS),

file=sys.stderr)

raise ValueError("Sort key must be one of: %s" %

if sys.platform == "win32":

return pathjoin(os.environ.get("HOMEDRIVE", ""),

os.environ.get("HOMEPATH", ""), ".litt")

else:

"""

try:

if isdir(__dotdir()):

if isfile("%s/events.json" % __dotdir()):

if isfile("%s/config.json" % __dotdir()):

return True

return False

except: # pylint: disable=W0702

"""

try:

os.makedirs(__dotdir(), mode=0o755)

except: # pylint: disable=W0702

pass

with open("%s/events.json" % __dotdir(), "w") as ofp:

ofp.write(

json.dumps(

{

"Stopwatch": None,

"Interruption": None,

"Aliases": dict(),

"Records": dict()

},

indent=2,

sort_keys=True))

with open("%s/config.json" % __dotdir(), "w") as ofp:

ofp.write(

"""

from os import listdir, access, X_OK

hooks = dict(pre_load=list(),

pre_commit=list(),

post_commit=list(),

pre_config_write=list(),

post_config_write=list())

for hook_key, binaries in hooks.items():

try:

for hookfile in listdir("%s/hooks/%s" % (__dotdir(), hook_key)):

hook_fullpath = "%s/hooks/%s/%s" % (__dotdir(), hook_key,

hookfile)

if isfile(hook_fullpath) and access(hook_fullpath, X_OK):

binaries.append(hook_fullpath)

binaries.sort()

except FileNotFoundError: # pylint: disable=E0602

pass

"""

import subprocess

for hookfile in hooks[hookevent]:

proc = subprocess.Popen((hookfile, hookevent),

stdout=subprocess.PIPE,

stdin=subprocess.PIPE,

stderr=subprocess.PIPE,

cwd=__dotdir())

proc.stdin.write(json.dumps(data, sort_keys=True).encode("utf-8"))

stdout, stderr = proc.communicate()

if proc.returncode != 0:

print("%s hook returned non-zero, aborting." % hookevent,

file=sys.stderr)

print(stdout.decode("utf-8"))

print(stderr.decode("utf-8"))

# An alias has a limited number of properties right now:

ret = ""

if "Description" in alias:

ret += " Description: %s\n" % alias["Description"]

if "Tags" in alias:

ret += " Tags: %s\n" % ",".join(alias["Tags"])

if "Detail" in alias:

ret += " Details:\n %s\n" % alias["Detail"]

if seconds < 60:

if seconds < 10:

duration_string = "%.2fs" % seconds

else:

duration_string = "%ds" % seconds

else:

hours = seconds // 3600

minutes = (seconds % 3600) // 60

duration_string = "%dh %02dm" % (hours, minutes)

ret = ""

if "StartTime" in record:

ret += "Record started at: %s\n" % __timestamp_to_iso(

record["StartTime"])

if "EndTime" in record:

if record["EndTime"] is None:

ret += "Recording is still ongoing.\n"

ret += "Elapsed wall-clock time: %s\n" % __seconds_to_hhmmss(

__parse_time("now") - record["StartTime"])

else:

ret += "Record ended at: %s\n" % __timestamp_to_iso(

record["EndTime"])

ret += "Elapsed wall-clock time: %s\n" % __seconds_to_hhmmss(

record["EndTime"] - record["StartTime"])

if "Interruptions" in record and record["Interruptions"] != []:

ret += "Number of interruptions: %s\n" % len(

record["Interruptions"])

interruption_duration = sum([

context[i["Id"]]["EndTime"] - context[i["Id"]]["StartTime"]

for i in record["Interruptions"]

])

ret += "Total interruption duration: %s\n" % __seconds_to_hhmmss(

interruption_duration)

ret += "Activity duration: %s\n" % __seconds_to_hhmmss(

record["EndTime"] - record["StartTime"] -

interruption_duration)

if "Description" in record:

ret += "Description: %s\n" % record["Description"]

if "Tags" in record:

ret += "Tags: %s\n" % ",".join(record["Tags"])

if "Detail" in record:

ret += "Details:\n %s\n" % record["Detail"]

if "StructuredData" in record:

ret += "StructuredData:\n %s\n" % record["StructuredData"]

pargs,

config,

human_hint,

dict_as_entries=False,

outfile=sys.stdout):

fmt = config[

"OutputFormat"] if pargs.output_format is None else pargs.output_format

if fmt == "json":

print(json.dumps(({i["key"]: i["value"]

for i in obj} if dict_as_entries else obj),

sort_keys=True,

indent=4),

file=outfile)

elif fmt == "json-compact":

print(json.dumps(({i["key"]: i["value"]

for i in obj} if dict_as_entries else obj),

sort_keys=True),

file=outfile)

elif fmt == "yaml":

print(yaml.dump(({i["key"]: i["value"]

for i in obj} if dict_as_entries else obj),

default_flow_style=False).strip(),

file=outfile)

elif fmt == "human":

# For human readable output, we need to know what the human hint is.

if human_hint == "ID":

# It's just an ID string, so just print it out saying so.

print("Committed Record ID: %s" % obj, file=outfile)

elif human_hint == "Config":

# It is the configuration object, so print it in pseudo-yaml

for k, v in obj.items():

print("%s: %s" % (str(k), str(v)), file=outfile)

elif human_hint.startswith("Alias"):

# This will always be a dictionary mapping alias keys to parameter sets.

for key, alias in obj.items():

print("Alias \"%s\"" % key, file=outfile)

print(__human_alias(alias), file=outfile)

elif human_hint.startswith("Record"):

# This will always be a dictionary, or dictionary as entries,

# but may sometimes be a bare record.

if "StartTime" in obj:

print(__human_record(obj), file=outfile)

else:

if dict_as_entries:

entry_dict = {

entry["key"]: entry["value"]

for entry in obj

}

for entry in obj:

key = entry["key"]

value = entry["value"]

if value.get("__Hidden", False):

continue

print("Record \"%s\"" % key, file=outfile)

print(__human_record(value, entry_dict), file=outfile)

else:

for key, value in obj.items():

if value.get("__Hidden", False):

continue

print("Record \"%s\"" % key, file=outfile)

print(__human_record(value, obj), file=outfile)

else:

"""

with open(pathjoin(__dotdir(), "events.json"), "r") as fp:

state = json.loads(fp.read())

with open(pathjoin(__dotdir(), "config.json"), "r") as fp:

config = json.loads(fp.read())

"""

with open("%s/events.json" % __dotdir(), "w") as ofp:

"""

run_hooks("pre_config_write", hooks, config)

with open("%s/config.json" % __dotdir(), "w") as ofp:

ofp.write(json.dumps(config, indent=2, sort_keys=True))

"""

if state["Stopwatch"] is not None:

__write_output(state["Stopwatch"],

pargs,

config,

"Record.Incomplete",

outfile=outfile)

if state["Interruption"] is not None:

__write_output(state["Interruption"],

pargs,

config,

"Record.Incomplete",

outfile=outfile)

"""

options = dict(output_format="OutputFormat")

opts = dict([(optkey, getattr(pargs, optkey))

for optkey in options.keys()]) # pylint: disable=C0201

# If all supported options are None (that is, unspecified), then just print the current

# configuration

if set(opts.values()) == set([None]):

__write_output(config, pargs, config, "Config")

# Otherwise, for those that are not None, update the values, and write them back to the file.

else:

for key, val in opts.items():

if val is not None:

config[options[key]] = val

__write_config(config, hooks)

"""

images = None

if pargs.key is None:

__write_output(state["Aliases"], pargs, config, "Alias.List")

else:

images = dict()

alias = dict()

if pargs.description is not None:

alias["Description"] = pargs.description

if pargs.detail is not None:

alias["Detail"] = pargs.detail

if pargs.structured_data is not None:

alias["StructuredData"] = base64.b64encode(pargs.structured_data)

if pargs.tag != []:

alias["Tags"] = pargs.tag

# Track the old image, which is the old alias config. If the alias doesn't exist yet, then

# the old image value is None

images["OldImage"] = {pargs.key: state["Aliases"].get(pargs.key, None)}

# Because len(alias) == 0 as a condition is against PEP8. We were essentially checking that

# the dictionary had stuff in it, so if it DOES NOT have stuff in it...

if not alias:

if pargs.key in state["Aliases"]:

del state["Aliases"][pargs.key]

images["NewImage"] = {pargs.key: None}

else:

state["Aliases"][pargs.key] = alias

images["NewImage"] = {pargs.key: alias}

"""

if pargs.quicktext is not None:

# Check it against aliases

if pargs.quicktext in state["Aliases"]:

pargs.alias = pargs.quicktext

# If it isn't an alias, use it as the description if --description is not provided

elif pargs.description is None:

"""

if pargs.alias not in state["Aliases"]:

return

alias = state["Aliases"][pargs.alias]

props = dict(

description="Description",

detail="Detail",

structured_data="StructuredData",

)

for key, val in props.items():

# If the alias property is nonempty, and the property was not specified, then fill in the

# property value from the alias. If the property WAS specified, then do NOT overwrite it

# with the alias.

#

# Note that not all keys are guaranteed to be in the alias.

if alias.get(val, None) is not None and getattr(pargs, key) is None:

setattr(pargs, key, alias[val])

# Tags are handled separately: append any tags in the alias to the tags in the input, and then

# remove any from the input's untag property.

#

# Note that pargs.tag is guaranteed to be a list, but the alias key doesn't even need to exist,

# let alone be a list.

pargs.tag += alias.get("Tags", [])

if "untag" in dir(pargs):

pargs.tag = list(set(pargs.tag).difference(set(pargs.untag)))

else:

__resolve_positional_arg(pargs, state)

if pargs.alias is not None:

__resolve_alias(pargs, state)

cur_time = time.time()

record = dict(

CommitTime=cur_time,

StartTime=cur_time,

EndTime=cur_time,

Tags=pargs.tag,

Description=pargs.description,

Detail=pargs.detail,

StructuredData=pargs.structured_data,

)

"""

if state["Stopwatch"] is not None:

print("Stopwatch currently running, ignoring current request",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(1)

else:

return None

record = __create_record(pargs, state)

if pargs.start_time is not None:

record["StartTime"] = __parse_time(pargs.start_time)

record["EndTime"] = None

record["CommitTime"] = None

record["Interruptions"] = []

state["Stopwatch"] = record

while True:

id_candidate = time.strftime("%Y%m%d") + (

"-%s" % "".join([chr(ord('A') + (c % 26)) for c in os.urandom(4)]))

if id_candidate not in state["Records"]:

break

# Given an input record, use the values in the pargs value to update any values in the old

# record, and replace the old record values.

# Given the pargs value, create the record for it, and then throw away any keys that have a

# value of None (the sentinel for "not supplied"; don't clobber a value in the old record that

# was unspecified in the new one).

new_record = dict([(k, v)

for k, v in __create_record(pargs, state).items()

if v is not None])

del new_record["StartTime"]

old_record = copy.deepcopy(old_record_prototype)

new_record["Tags"] = list(

set(old_record["Tags"] + new_record["Tags"]).difference(

set(pargs.untag)))

old_record.update(new_record)

"""

if state["Interruption"] is not None:

print("Interruption is in progress, ignoring current request",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(13)

else:

return None

if state["Stopwatch"] is None:

print("Stopwatch not currently running, ignoring current request",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(2)

else:

return None

if pargs.id is None:

pargs.id = __generate_id(state)

record = __update_record(state["Stopwatch"], pargs, state)

if pargs.end_time is not None:

record["EndTime"] = __parse_time(pargs.end_time)

state["Stopwatch"] = None

state["Records"][pargs.id] = record

__write_output(pargs.id, pargs, config, "ID", outfile=outfile)

# Return the images, with None for the old image.

"""

# Since this is essentially just start or stop, but context sensitive, determine if there is

# a stopwatch running, and call the right function.

if state["Stopwatch"] is None:

return cmd_start(pargs, state, config, outfile)

else:

"""

# Since this is essentially just start or stop, but context sensitive, determine if there is

# a stopwatch running, and call the right function.

if state["Interruption"] is None:

return cmd_interrupt(pargs, state, config, outfile)

else:

"""

if state["Interruption"] is not None:

state["Interruption"] = None

else:

"""

if state["Stopwatch"] is None:

if not hasattr(pargs, "start_time"):

pargs.start_time = None

cmd_start(pargs, state, config, outfile)

else:

# Confirm that there are no ongoing interruptions

if state["Interruption"] is not None:

print(

"Unable to interrupt task, as existing interruption is in progress.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(3)

else:

return None

# Since at this point, there's no ongoing interruptions, add a new one to the end of the

# Interruptions list

record = __create_record(pargs, state)

record["EndTime"] = None

record["CommitTime"] = None

"""

if state["Stopwatch"] is None:

print("Unable to resume from interruption with no stopwatch running.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(4)

else:

return None

else:

# Confirm that the interruption that's most recent exists and is indeed still open

if state["Interruption"] is None:

print("Unable to resume without an open interruption.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(5)

else:

return None

# Since there's an open interruption, close it out.

if pargs.id is None:

pargs.id = __generate_id(state)

record = __update_record(state["Interruption"], pargs, state)

state["Records"][pargs.id] = record

state["Interruption"] = None

state["Stopwatch"]["Interruptions"].append(dict(Id=pargs.id))

__write_output(pargs.id, pargs, config, "ID", outfile=outfile)

# Return the images, with None for the old image.

from dateparser import parse as datetimeparser

from dateutil.tz import tzlocal

dto = datetimeparser(timespec)

if dto is None:

print("Unable to parse your timespec \"%s\"." % timespec,

file=sys.stderr)

sys.exit(8)

if dto.tzinfo is None:

return dto.replace(tzinfo=tzlocal()).timestamp()

"""

if pargs.id is None:

pargs.id = __generate_id(state)

cur_time = time.time()

if pargs.start_time is None and pargs.end_time is None:

print(

"At least one of start and end of a finite interval must be specified.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(6)

else:

return None

# Since the above check guarantees at least one was specified, set the other to

# a timezone aware "now" (in UTC).

if pargs.start_time is None:

pargs.start_time = "now UTC"

if pargs.end_time is None:

pargs.end_time = "now UTC"

start_time = __parse_time(pargs.start_time)

end_time = __parse_time(pargs.end_time)

if end_time - start_time <= 0:

print(

"For finite-interval tracking, the end time must be strictly after the start time.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(7)

else:

return None

record = __create_record(pargs, state)

record["StartTime"] = start_time

record["EndTime"] = end_time

record["CommitTime"] = cur_time

if pargs.dryrun:

__write_output(record, pargs, config, "Record.Complete")

if outfile == sys.stdout:

sys.exit(127)

else:

return None

else:

state["Records"][pargs.id] = record

__write_output(pargs.id, pargs, config, "ID", outfile=outfile)

# Return the images, with None for the old image.

"""

if pargs.id is None and state["Stopwatch"] is None:

print(

"No record ID specified, and no stopwatch running to default to.",

file=sys.stderr)

if outfile == sys.stdout:

sys.exit(9)

else:

return None

# First, check that the ID specified exists.

if pargs.id is not None and pargs.id not in state["Records"]:

print("Specified record ID does not exist.", file=sys.stderr)

if outfile == sys.stdout:

sys.exit(9)

else:

return None

# If the ID exists, create a new record from the arguments, and then clobber the record pulled

# from the ledger.

if pargs.id is None:

images = None

old_record = state["Stopwatch"]

record = __update_record(copy.deepcopy(state["Stopwatch"]), pargs,

state)

else:

images = dict()

images["OldImage"] = {

pargs.id: copy.deepcopy(state["Records"][pargs.id])

}

old_record = state["Records"][pargs.id]

record = __update_record(old_record, pargs, state)

# Reset the timestamps in the record to what the original record was, then we'll replace as

# necessary based on what is provided in the pargs attributes.

record["StartTime"] = old_record["StartTime"]

record["EndTime"] = old_record["EndTime"]

# Fix the weirdness that's going to go on with the timestamps

if pargs.start_time is not None:

record["StartTime"] = __parse_time(pargs.start_time)

if pargs.end_time is not None:

record["EndTime"] = __parse_time(pargs.end_time)

if pargs.id is None:

state["Stopwatch"] = record

else:

images["NewImage"] = {pargs.id: record}

state["Records"][pargs.id] = record

for timespec in timespeclist:

dto = __parse_time(timespec["Timespec"])

if eval(repr(timestamp) + timespec["Condition"] + repr(dto)):

return True

import re

if stringval is None:

return False

for pattern in regexlist:

if re.search(pattern, stringval):

return True

filters = {

"Tags": __check_tag_filter,

"StartTime": __check_timespec_filter,

"EndTime": __check_timespec_filter,

"Description": __check_regex_filter,

"Detail": __check_regex_filter

}

results = dict()

for record_id, record in records.items():

for k, v in filters.items():

if k in record and k in sieve and v(record[k], sieve[k]):

results[record_id] = record

from datetime import datetime

from dateutil.tz import tzlocal

return datetime.fromtimestamp(timestamp).replace(

from collections import Counter

from csv import DictWriter

# Print out a CSV with the following header structure

# RecordID StartTime EndTime CommitTime Duration InterruptionDuration Description Detail [StructuredData] Tag1 Tag2 ...

#

# Tags that appear in all records are omitted, and 'x' is placed in the column for rows that

# have that tag.

#

# Timestamps are converted from UTC Unix tiemstamps to ISO timestamps in the local timezone.

#

# For records with interruptions, the time will be subtracted from the Duration value, so

# the duration may not match the difference between start and end time.

tags = list()

rows = copy.deepcopy(records)

# The input is always a list of dictionary items as entries of the form

# [{"key": ..., "value": ...}, ...]

for entry in rows:

key = entry["key"]

val = entry["value"]

val["RecordId"] = key

val["Duration"] = (val["EndTime"] - val["StartTime"]) / 3600

val["InterruptionDuration"] = 0.0

for event in val.get("Interruptions", []):

val["InterruptionDuration"] += (

allrecords[event["Id"]]["EndTime"] -

allrecords[event["Id"]]["StartTime"]) / 3600

val["Duration"] -= val["InterruptionDuration"] / 3600

val["StartTime"] = __timestamp_to_iso(val["StartTime"])

val["EndTime"] = __timestamp_to_iso(val["EndTime"])

val["CommitTime"] = __timestamp_to_iso(val["CommitTime"])

if "Tags" in val:

tags += val["Tags"]

for tag in val["Tags"]:

val[tag] = "x"

del val["Tags"]

tag_counts = Counter(tags)

ignored_tags = [k for k, v in tag_counts.items() if v == len(records)]

tag_columns = sorted(

list(set(list(tag_counts.keys())).difference(set(ignored_tags))))

column_names = [

"RecordId", "StartTime", "EndTime", "CommitTime", "Duration",

"InterruptionDuration", "Description"

] + ([] if pargs.without_detail else ["Detail"]) + (

["StructuredData"] if pargs.with_structured_data else []) + tag_columns

csv = DictWriter(outfile, column_names)

csv.writeheader()

csv.writerows([{

col_name: entry["value"].get(col_name, "")

for col_name in column_names

"""

if pargs.pos_id is not None:

pargs.id.append(pargs.pos_id)

if pargs.id != []:

results = {

rid: copy.deepcopy(state["Records"].get(rid, None))

for rid in pargs.id if rid in state["Records"]

}

else:

results = copy.deepcopy(state["Records"])

for sieve in pargs.filter:

results = __filter_records(sieve, results)

# Now, loop through to find the smallest set containing all of the specified records

# and any of their referenced records (i.e. interruptions)

more_ids = set([

i["Id"] for rec_id, rec in results.items()

for i in rec.get("Interruptions", list())

])

more_ids = more_ids.difference(set(results.keys()))

while more_ids != set():

for rec_id in more_ids:

results[rec_id] = copy.deepcopy(state["Records"][rec_id])

results[rec_id]["__Hidden"] = True

more_ids = set([

i["Id"] for rec_id, rec in results.items()

for i in rec.get("Interruptions", list())

])

more_ids = more_ids.difference(set(results.keys()))

if not pargs.with_structured_data:

for _, val in results.items():

if "StructuredData" in val:

del val["StructuredData"]

if pargs.without_detail:

for _, val in results.items():

if "Detail" in val:

del val["Detail"]

results_list = [{"key": k, "value": v} for k, v in results.items()]

try:

results_list.sort(key=lambda d: d["value"][pargs.sort_by]

if pargs.sort_by != "ID" else d["key"])

if pargs.last is not None:

# If --last was specified, then only take the last N (or first N)

# entries, keeping all of the hidden ones.

results_list = [

result

for result in results_list if result.get("__Hidden", False)

] + (lambda l: l[-pargs.last:]

if pargs.last > 0 else l[:-pargs.last])([

result for result in results_list

if not result.get("__Hidden", False)

])

except Exception as e:

print("Error sorting log output.", repr(e), file=sys.stderr)

sys.exit(12)

if pargs.csv:

__csv_format(results_list, state["Records"], pargs, outfile)

else:

__write_output(results_list,

pargs,

config,

"Record.Complete.List",

dict_as_entries=True,

outfile=outfile)

parser.add_argument(

default=None,

nargs="?",

dest="quicktext",

help=

"""Positional argument that is first checked as an alias key and, failing that, used as the

parser.add_argument(

"-d",

"--description",

required=False,

default=None,

metavar="<description>",

help="""A short description of the work done during the time tracked."""

)

parser.add_argument(

"-D",

"--detail",

required=False,

default=None,

metavar="<detail>",

help=

"""A detailed description of the work done during the time tracked.""")

parser.add_argument(

"-t",

"--tag",

action="append",

required=False,

default=[],

metavar="<tag>",

help=

"""Include a tag for the tracked unit of time. Specify multiple times to include multiple

tags.""")

parser.add_argument(

"-S",

"--structured-data",

required=False,

default=None,

metavar="<data>",

help=

"""Arbitrary data to associate with the time record, base64 encoded before storing."""