repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
bram85/topydo | topydo/ui/columns/CommandLineWidget.py | CommandLineWidget._complete | def _complete(self):
"""
Main completion function.
Gets list of potential completion candidates for currently edited word,
completes it to the longest common part, and shows convenient completion
widget (if multiple completions are returned) with currently selected
candidate highlighted.
"""
def find_word_start(p_text, p_pos):
""" Returns position of the beginning of a word ending in p_pos. """
return p_text.lstrip().rfind(' ', 0, p_pos) + 1
def get_word_before_pos(p_text, p_pos):
start = find_word_start(p_text, p_pos)
return (p_text[start:p_pos], start)
pos = self.edit_pos
text = self.edit_text
completer = self.completer
word_before_cursor, start = get_word_before_pos(text, pos)
completions = completer.get_completions(word_before_cursor, start == 0)
# store slices before and after place for completion
self._surrounding_text = (text[:start], text[pos:])
single_completion = len(completions) == 1
completion_done = single_completion and completions[0] == word_before_cursor
if completion_done or not completions:
self.completion_mode = False
return
elif single_completion:
replacement = completions[0]
else:
replacement = commonprefix(completions)
zero_candidate = replacement if replacement else word_before_cursor
if zero_candidate != completions[0]:
completions.insert(0, zero_candidate)
self.completion_box.add_completions(completions)
self.insert_completion(replacement)
self.completion_mode = not single_completion | python | def _complete(self):
"""
Main completion function.
Gets list of potential completion candidates for currently edited word,
completes it to the longest common part, and shows convenient completion
widget (if multiple completions are returned) with currently selected
candidate highlighted.
"""
def find_word_start(p_text, p_pos):
""" Returns position of the beginning of a word ending in p_pos. """
return p_text.lstrip().rfind(' ', 0, p_pos) + 1
def get_word_before_pos(p_text, p_pos):
start = find_word_start(p_text, p_pos)
return (p_text[start:p_pos], start)
pos = self.edit_pos
text = self.edit_text
completer = self.completer
word_before_cursor, start = get_word_before_pos(text, pos)
completions = completer.get_completions(word_before_cursor, start == 0)
# store slices before and after place for completion
self._surrounding_text = (text[:start], text[pos:])
single_completion = len(completions) == 1
completion_done = single_completion and completions[0] == word_before_cursor
if completion_done or not completions:
self.completion_mode = False
return
elif single_completion:
replacement = completions[0]
else:
replacement = commonprefix(completions)
zero_candidate = replacement if replacement else word_before_cursor
if zero_candidate != completions[0]:
completions.insert(0, zero_candidate)
self.completion_box.add_completions(completions)
self.insert_completion(replacement)
self.completion_mode = not single_completion | [
"def",
"_complete",
"(",
"self",
")",
":",
"def",
"find_word_start",
"(",
"p_text",
",",
"p_pos",
")",
":",
"\"\"\" Returns position of the beginning of a word ending in p_pos. \"\"\"",
"return",
"p_text",
".",
"lstrip",
"(",
")",
".",
"rfind",
"(",
"' '",
",",
"0",
",",
"p_pos",
")",
"+",
"1",
"def",
"get_word_before_pos",
"(",
"p_text",
",",
"p_pos",
")",
":",
"start",
"=",
"find_word_start",
"(",
"p_text",
",",
"p_pos",
")",
"return",
"(",
"p_text",
"[",
"start",
":",
"p_pos",
"]",
",",
"start",
")",
"pos",
"=",
"self",
".",
"edit_pos",
"text",
"=",
"self",
".",
"edit_text",
"completer",
"=",
"self",
".",
"completer",
"word_before_cursor",
",",
"start",
"=",
"get_word_before_pos",
"(",
"text",
",",
"pos",
")",
"completions",
"=",
"completer",
".",
"get_completions",
"(",
"word_before_cursor",
",",
"start",
"==",
"0",
")",
"# store slices before and after place for completion",
"self",
".",
"_surrounding_text",
"=",
"(",
"text",
"[",
":",
"start",
"]",
",",
"text",
"[",
"pos",
":",
"]",
")",
"single_completion",
"=",
"len",
"(",
"completions",
")",
"==",
"1",
"completion_done",
"=",
"single_completion",
"and",
"completions",
"[",
"0",
"]",
"==",
"word_before_cursor",
"if",
"completion_done",
"or",
"not",
"completions",
":",
"self",
".",
"completion_mode",
"=",
"False",
"return",
"elif",
"single_completion",
":",
"replacement",
"=",
"completions",
"[",
"0",
"]",
"else",
":",
"replacement",
"=",
"commonprefix",
"(",
"completions",
")",
"zero_candidate",
"=",
"replacement",
"if",
"replacement",
"else",
"word_before_cursor",
"if",
"zero_candidate",
"!=",
"completions",
"[",
"0",
"]",
":",
"completions",
".",
"insert",
"(",
"0",
",",
"zero_candidate",
")",
"self",
".",
"completion_box",
".",
"add_completions",
"(",
"completions",
")",
"self",
".",
"insert_completion",
"(",
"replacement",
")",
"self",
".",
"completion_mode",
"=",
"not",
"single_completion"
] | Main completion function.
Gets list of potential completion candidates for currently edited word,
completes it to the longest common part, and shows convenient completion
widget (if multiple completions are returned) with currently selected
candidate highlighted. | [
"Main",
"completion",
"function",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/CommandLineWidget.py#L110-L155 | train |
bram85/topydo | topydo/ui/columns/CommandLineWidget.py | CommandLineWidget._home_del | def _home_del(self):
""" Deletes the line content before the cursor """
text = self.edit_text[self.edit_pos:]
self.set_edit_text(text)
self._home() | python | def _home_del(self):
""" Deletes the line content before the cursor """
text = self.edit_text[self.edit_pos:]
self.set_edit_text(text)
self._home() | [
"def",
"_home_del",
"(",
"self",
")",
":",
"text",
"=",
"self",
".",
"edit_text",
"[",
"self",
".",
"edit_pos",
":",
"]",
"self",
".",
"set_edit_text",
"(",
"text",
")",
"self",
".",
"_home",
"(",
")"
] | Deletes the line content before the cursor | [
"Deletes",
"the",
"line",
"content",
"before",
"the",
"cursor"
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/CommandLineWidget.py#L197-L201 | train |
bram85/topydo | topydo/ui/columns/CommandLineWidget.py | CommandLineWidget._end_del | def _end_del(self):
""" Deletes the line content after the cursor """
text = self.edit_text[:self.edit_pos]
self.set_edit_text(text) | python | def _end_del(self):
""" Deletes the line content after the cursor """
text = self.edit_text[:self.edit_pos]
self.set_edit_text(text) | [
"def",
"_end_del",
"(",
"self",
")",
":",
"text",
"=",
"self",
".",
"edit_text",
"[",
":",
"self",
".",
"edit_pos",
"]",
"self",
".",
"set_edit_text",
"(",
"text",
")"
] | Deletes the line content after the cursor | [
"Deletes",
"the",
"line",
"content",
"after",
"the",
"cursor"
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/CommandLineWidget.py#L203-L206 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.add_edge | def add_edge(self, p_from, p_to, p_id=None):
"""
Adds an edge to the graph. The nodes will be added if they don't exist.
The p_id is the id of the edge, if the client wishes to maintain this.
"""
if not self.has_edge(p_from, p_to):
if not self.has_node(p_from):
self.add_node(p_from)
if not self.has_node(p_to):
self.add_node(p_to)
self._edges[p_from].add(p_to)
self._edge_numbers[(p_from, p_to)] = p_id | python | def add_edge(self, p_from, p_to, p_id=None):
"""
Adds an edge to the graph. The nodes will be added if they don't exist.
The p_id is the id of the edge, if the client wishes to maintain this.
"""
if not self.has_edge(p_from, p_to):
if not self.has_node(p_from):
self.add_node(p_from)
if not self.has_node(p_to):
self.add_node(p_to)
self._edges[p_from].add(p_to)
self._edge_numbers[(p_from, p_to)] = p_id | [
"def",
"add_edge",
"(",
"self",
",",
"p_from",
",",
"p_to",
",",
"p_id",
"=",
"None",
")",
":",
"if",
"not",
"self",
".",
"has_edge",
"(",
"p_from",
",",
"p_to",
")",
":",
"if",
"not",
"self",
".",
"has_node",
"(",
"p_from",
")",
":",
"self",
".",
"add_node",
"(",
"p_from",
")",
"if",
"not",
"self",
".",
"has_node",
"(",
"p_to",
")",
":",
"self",
".",
"add_node",
"(",
"p_to",
")",
"self",
".",
"_edges",
"[",
"p_from",
"]",
".",
"add",
"(",
"p_to",
")",
"self",
".",
"_edge_numbers",
"[",
"(",
"p_from",
",",
"p_to",
")",
"]",
"=",
"p_id"
] | Adds an edge to the graph. The nodes will be added if they don't exist.
The p_id is the id of the edge, if the client wishes to maintain this. | [
"Adds",
"an",
"edge",
"to",
"the",
"graph",
".",
"The",
"nodes",
"will",
"be",
"added",
"if",
"they",
"don",
"t",
"exist",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L39-L53 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.reachable_nodes | def reachable_nodes(self, p_id, p_recursive=True, p_reverse=False):
"""
Returns the set of all neighbors that the given node can reach.
If recursive, it will also return the neighbor's neighbors, etc.
If reverse, the arrows are reversed and then the reachable neighbors
are located.
"""
stack = [p_id]
visited = set()
result = set()
while len(stack):
current = stack.pop()
if current in visited or current not in self._edges:
continue
visited.add(current)
if p_reverse:
parents = [node for node, neighbors in self._edges.items()
if current in neighbors]
stack = stack + parents
result = result.union(parents)
else:
stack = stack + list(self._edges[current])
result = result.union(self._edges[current])
if not p_recursive:
break
return result | python | def reachable_nodes(self, p_id, p_recursive=True, p_reverse=False):
"""
Returns the set of all neighbors that the given node can reach.
If recursive, it will also return the neighbor's neighbors, etc.
If reverse, the arrows are reversed and then the reachable neighbors
are located.
"""
stack = [p_id]
visited = set()
result = set()
while len(stack):
current = stack.pop()
if current in visited or current not in self._edges:
continue
visited.add(current)
if p_reverse:
parents = [node for node, neighbors in self._edges.items()
if current in neighbors]
stack = stack + parents
result = result.union(parents)
else:
stack = stack + list(self._edges[current])
result = result.union(self._edges[current])
if not p_recursive:
break
return result | [
"def",
"reachable_nodes",
"(",
"self",
",",
"p_id",
",",
"p_recursive",
"=",
"True",
",",
"p_reverse",
"=",
"False",
")",
":",
"stack",
"=",
"[",
"p_id",
"]",
"visited",
"=",
"set",
"(",
")",
"result",
"=",
"set",
"(",
")",
"while",
"len",
"(",
"stack",
")",
":",
"current",
"=",
"stack",
".",
"pop",
"(",
")",
"if",
"current",
"in",
"visited",
"or",
"current",
"not",
"in",
"self",
".",
"_edges",
":",
"continue",
"visited",
".",
"add",
"(",
"current",
")",
"if",
"p_reverse",
":",
"parents",
"=",
"[",
"node",
"for",
"node",
",",
"neighbors",
"in",
"self",
".",
"_edges",
".",
"items",
"(",
")",
"if",
"current",
"in",
"neighbors",
"]",
"stack",
"=",
"stack",
"+",
"parents",
"result",
"=",
"result",
".",
"union",
"(",
"parents",
")",
"else",
":",
"stack",
"=",
"stack",
"+",
"list",
"(",
"self",
".",
"_edges",
"[",
"current",
"]",
")",
"result",
"=",
"result",
".",
"union",
"(",
"self",
".",
"_edges",
"[",
"current",
"]",
")",
"if",
"not",
"p_recursive",
":",
"break",
"return",
"result"
] | Returns the set of all neighbors that the given node can reach.
If recursive, it will also return the neighbor's neighbors, etc.
If reverse, the arrows are reversed and then the reachable neighbors
are located. | [
"Returns",
"the",
"set",
"of",
"all",
"neighbors",
"that",
"the",
"given",
"node",
"can",
"reach",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L73-L106 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.reachable_nodes_reverse | def reachable_nodes_reverse(self, p_id, p_recursive=True):
""" Find neighbors in the inverse graph. """
return self.reachable_nodes(p_id, p_recursive, True) | python | def reachable_nodes_reverse(self, p_id, p_recursive=True):
""" Find neighbors in the inverse graph. """
return self.reachable_nodes(p_id, p_recursive, True) | [
"def",
"reachable_nodes_reverse",
"(",
"self",
",",
"p_id",
",",
"p_recursive",
"=",
"True",
")",
":",
"return",
"self",
".",
"reachable_nodes",
"(",
"p_id",
",",
"p_recursive",
",",
"True",
")"
] | Find neighbors in the inverse graph. | [
"Find",
"neighbors",
"in",
"the",
"inverse",
"graph",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L108-L110 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.remove_node | def remove_node(self, p_id, remove_unconnected_nodes=True):
""" Removes a node from the graph. """
if self.has_node(p_id):
for neighbor in self.incoming_neighbors(p_id):
self._edges[neighbor].remove(p_id)
neighbors = set()
if remove_unconnected_nodes:
neighbors = self.outgoing_neighbors(p_id)
del self._edges[p_id]
for neighbor in neighbors:
if self.is_isolated(neighbor):
self.remove_node(neighbor) | python | def remove_node(self, p_id, remove_unconnected_nodes=True):
""" Removes a node from the graph. """
if self.has_node(p_id):
for neighbor in self.incoming_neighbors(p_id):
self._edges[neighbor].remove(p_id)
neighbors = set()
if remove_unconnected_nodes:
neighbors = self.outgoing_neighbors(p_id)
del self._edges[p_id]
for neighbor in neighbors:
if self.is_isolated(neighbor):
self.remove_node(neighbor) | [
"def",
"remove_node",
"(",
"self",
",",
"p_id",
",",
"remove_unconnected_nodes",
"=",
"True",
")",
":",
"if",
"self",
".",
"has_node",
"(",
"p_id",
")",
":",
"for",
"neighbor",
"in",
"self",
".",
"incoming_neighbors",
"(",
"p_id",
")",
":",
"self",
".",
"_edges",
"[",
"neighbor",
"]",
".",
"remove",
"(",
"p_id",
")",
"neighbors",
"=",
"set",
"(",
")",
"if",
"remove_unconnected_nodes",
":",
"neighbors",
"=",
"self",
".",
"outgoing_neighbors",
"(",
"p_id",
")",
"del",
"self",
".",
"_edges",
"[",
"p_id",
"]",
"for",
"neighbor",
"in",
"neighbors",
":",
"if",
"self",
".",
"is_isolated",
"(",
"neighbor",
")",
":",
"self",
".",
"remove_node",
"(",
"neighbor",
")"
] | Removes a node from the graph. | [
"Removes",
"a",
"node",
"from",
"the",
"graph",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L112-L126 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.is_isolated | def is_isolated(self, p_id):
"""
Returns True iff the given node has no incoming or outgoing edges.
"""
return(len(self.incoming_neighbors(p_id)) == 0
and len(self.outgoing_neighbors(p_id)) == 0) | python | def is_isolated(self, p_id):
"""
Returns True iff the given node has no incoming or outgoing edges.
"""
return(len(self.incoming_neighbors(p_id)) == 0
and len(self.outgoing_neighbors(p_id)) == 0) | [
"def",
"is_isolated",
"(",
"self",
",",
"p_id",
")",
":",
"return",
"(",
"len",
"(",
"self",
".",
"incoming_neighbors",
"(",
"p_id",
")",
")",
"==",
"0",
"and",
"len",
"(",
"self",
".",
"outgoing_neighbors",
"(",
"p_id",
")",
")",
"==",
"0",
")"
] | Returns True iff the given node has no incoming or outgoing edges. | [
"Returns",
"True",
"iff",
"the",
"given",
"node",
"has",
"no",
"incoming",
"or",
"outgoing",
"edges",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L128-L133 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.has_edge | def has_edge(self, p_from, p_to):
""" Returns True when the graph has the given edge. """
return p_from in self._edges and p_to in self._edges[p_from] | python | def has_edge(self, p_from, p_to):
""" Returns True when the graph has the given edge. """
return p_from in self._edges and p_to in self._edges[p_from] | [
"def",
"has_edge",
"(",
"self",
",",
"p_from",
",",
"p_to",
")",
":",
"return",
"p_from",
"in",
"self",
".",
"_edges",
"and",
"p_to",
"in",
"self",
".",
"_edges",
"[",
"p_from",
"]"
] | Returns True when the graph has the given edge. | [
"Returns",
"True",
"when",
"the",
"graph",
"has",
"the",
"given",
"edge",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L135-L137 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.remove_edge | def remove_edge(self, p_from, p_to, p_remove_unconnected_nodes=True):
"""
Removes an edge from the graph.
When remove_unconnected_nodes is True, then the nodes are also removed
if they become isolated.
"""
if self.has_edge(p_from, p_to):
self._edges[p_from].remove(p_to)
try:
del self._edge_numbers[(p_from, p_to)]
except KeyError:
return None
if p_remove_unconnected_nodes:
if self.is_isolated(p_from):
self.remove_node(p_from)
if self.is_isolated(p_to):
self.remove_node(p_to) | python | def remove_edge(self, p_from, p_to, p_remove_unconnected_nodes=True):
"""
Removes an edge from the graph.
When remove_unconnected_nodes is True, then the nodes are also removed
if they become isolated.
"""
if self.has_edge(p_from, p_to):
self._edges[p_from].remove(p_to)
try:
del self._edge_numbers[(p_from, p_to)]
except KeyError:
return None
if p_remove_unconnected_nodes:
if self.is_isolated(p_from):
self.remove_node(p_from)
if self.is_isolated(p_to):
self.remove_node(p_to) | [
"def",
"remove_edge",
"(",
"self",
",",
"p_from",
",",
"p_to",
",",
"p_remove_unconnected_nodes",
"=",
"True",
")",
":",
"if",
"self",
".",
"has_edge",
"(",
"p_from",
",",
"p_to",
")",
":",
"self",
".",
"_edges",
"[",
"p_from",
"]",
".",
"remove",
"(",
"p_to",
")",
"try",
":",
"del",
"self",
".",
"_edge_numbers",
"[",
"(",
"p_from",
",",
"p_to",
")",
"]",
"except",
"KeyError",
":",
"return",
"None",
"if",
"p_remove_unconnected_nodes",
":",
"if",
"self",
".",
"is_isolated",
"(",
"p_from",
")",
":",
"self",
".",
"remove_node",
"(",
"p_from",
")",
"if",
"self",
".",
"is_isolated",
"(",
"p_to",
")",
":",
"self",
".",
"remove_node",
"(",
"p_to",
")"
] | Removes an edge from the graph.
When remove_unconnected_nodes is True, then the nodes are also removed
if they become isolated. | [
"Removes",
"an",
"edge",
"from",
"the",
"graph",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L156-L176 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.transitively_reduce | def transitively_reduce(self):
"""
Performs a transitive reduction on the graph.
"""
removals = set()
for from_node, neighbors in self._edges.items():
childpairs = \
[(c1, c2) for c1 in neighbors for c2 in neighbors if c1 != c2]
for child1, child2 in childpairs:
if self.has_path(child1, child2) \
and not self.has_path(child1, from_node):
removals.add((from_node, child2))
for edge in removals:
self.remove_edge(edge[0], edge[1]) | python | def transitively_reduce(self):
"""
Performs a transitive reduction on the graph.
"""
removals = set()
for from_node, neighbors in self._edges.items():
childpairs = \
[(c1, c2) for c1 in neighbors for c2 in neighbors if c1 != c2]
for child1, child2 in childpairs:
if self.has_path(child1, child2) \
and not self.has_path(child1, from_node):
removals.add((from_node, child2))
for edge in removals:
self.remove_edge(edge[0], edge[1]) | [
"def",
"transitively_reduce",
"(",
"self",
")",
":",
"removals",
"=",
"set",
"(",
")",
"for",
"from_node",
",",
"neighbors",
"in",
"self",
".",
"_edges",
".",
"items",
"(",
")",
":",
"childpairs",
"=",
"[",
"(",
"c1",
",",
"c2",
")",
"for",
"c1",
"in",
"neighbors",
"for",
"c2",
"in",
"neighbors",
"if",
"c1",
"!=",
"c2",
"]",
"for",
"child1",
",",
"child2",
"in",
"childpairs",
":",
"if",
"self",
".",
"has_path",
"(",
"child1",
",",
"child2",
")",
"and",
"not",
"self",
".",
"has_path",
"(",
"child1",
",",
"from_node",
")",
":",
"removals",
".",
"add",
"(",
"(",
"from_node",
",",
"child2",
")",
")",
"for",
"edge",
"in",
"removals",
":",
"self",
".",
"remove_edge",
"(",
"edge",
"[",
"0",
"]",
",",
"edge",
"[",
"1",
"]",
")"
] | Performs a transitive reduction on the graph. | [
"Performs",
"a",
"transitive",
"reduction",
"on",
"the",
"graph",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L178-L194 | train |
bram85/topydo | topydo/lib/Graph.py | DirectedGraph.dot | def dot(self, p_print_labels=True):
""" Prints the graph in Dot format. """
out = 'digraph g {\n'
for from_node, neighbors in sorted(self._edges.items()):
out += " {}\n".format(from_node)
for neighbor in sorted(neighbors):
out += " {} -> {}".format(from_node, neighbor)
edge_id = self.edge_id(from_node, neighbor)
if edge_id and p_print_labels:
out += ' [label="{}"]'.format(edge_id)
out += "\n"
out += '}\n'
return out | python | def dot(self, p_print_labels=True):
""" Prints the graph in Dot format. """
out = 'digraph g {\n'
for from_node, neighbors in sorted(self._edges.items()):
out += " {}\n".format(from_node)
for neighbor in sorted(neighbors):
out += " {} -> {}".format(from_node, neighbor)
edge_id = self.edge_id(from_node, neighbor)
if edge_id and p_print_labels:
out += ' [label="{}"]'.format(edge_id)
out += "\n"
out += '}\n'
return out | [
"def",
"dot",
"(",
"self",
",",
"p_print_labels",
"=",
"True",
")",
":",
"out",
"=",
"'digraph g {\\n'",
"for",
"from_node",
",",
"neighbors",
"in",
"sorted",
"(",
"self",
".",
"_edges",
".",
"items",
"(",
")",
")",
":",
"out",
"+=",
"\" {}\\n\"",
".",
"format",
"(",
"from_node",
")",
"for",
"neighbor",
"in",
"sorted",
"(",
"neighbors",
")",
":",
"out",
"+=",
"\" {} -> {}\"",
".",
"format",
"(",
"from_node",
",",
"neighbor",
")",
"edge_id",
"=",
"self",
".",
"edge_id",
"(",
"from_node",
",",
"neighbor",
")",
"if",
"edge_id",
"and",
"p_print_labels",
":",
"out",
"+=",
"' [label=\"{}\"]'",
".",
"format",
"(",
"edge_id",
")",
"out",
"+=",
"\"\\n\"",
"out",
"+=",
"'}\\n'",
"return",
"out"
] | Prints the graph in Dot format. | [
"Prints",
"the",
"graph",
"in",
"Dot",
"format",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Graph.py#L196-L213 | train |
bram85/topydo | topydo/commands/ListCommand.py | ListCommand._print | def _print(self):
"""
Prints the todos in the right format.
Defaults to normal text output (with possible colors and other pretty
printing). If a format was specified on the commandline, this format is
sent to the output.
"""
if self.printer is None:
# create a standard printer with some filters
indent = config().list_indent()
final_format = ' ' * indent + self.format
filters = []
filters.append(PrettyPrinterFormatFilter(self.todolist, final_format))
self.printer = pretty_printer_factory(self.todolist, filters)
try:
if self.group_expression:
self.out(self.printer.print_groups(self._view().groups))
else:
self.out(self.printer.print_list(self._view().todos))
except ListFormatError:
self.error('Error while parsing format string (list_format config'
' option or -F)') | python | def _print(self):
"""
Prints the todos in the right format.
Defaults to normal text output (with possible colors and other pretty
printing). If a format was specified on the commandline, this format is
sent to the output.
"""
if self.printer is None:
# create a standard printer with some filters
indent = config().list_indent()
final_format = ' ' * indent + self.format
filters = []
filters.append(PrettyPrinterFormatFilter(self.todolist, final_format))
self.printer = pretty_printer_factory(self.todolist, filters)
try:
if self.group_expression:
self.out(self.printer.print_groups(self._view().groups))
else:
self.out(self.printer.print_list(self._view().todos))
except ListFormatError:
self.error('Error while parsing format string (list_format config'
' option or -F)') | [
"def",
"_print",
"(",
"self",
")",
":",
"if",
"self",
".",
"printer",
"is",
"None",
":",
"# create a standard printer with some filters",
"indent",
"=",
"config",
"(",
")",
".",
"list_indent",
"(",
")",
"final_format",
"=",
"' '",
"*",
"indent",
"+",
"self",
".",
"format",
"filters",
"=",
"[",
"]",
"filters",
".",
"append",
"(",
"PrettyPrinterFormatFilter",
"(",
"self",
".",
"todolist",
",",
"final_format",
")",
")",
"self",
".",
"printer",
"=",
"pretty_printer_factory",
"(",
"self",
".",
"todolist",
",",
"filters",
")",
"try",
":",
"if",
"self",
".",
"group_expression",
":",
"self",
".",
"out",
"(",
"self",
".",
"printer",
".",
"print_groups",
"(",
"self",
".",
"_view",
"(",
")",
".",
"groups",
")",
")",
"else",
":",
"self",
".",
"out",
"(",
"self",
".",
"printer",
".",
"print_list",
"(",
"self",
".",
"_view",
"(",
")",
".",
"todos",
")",
")",
"except",
"ListFormatError",
":",
"self",
".",
"error",
"(",
"'Error while parsing format string (list_format config'",
"' option or -F)'",
")"
] | Prints the todos in the right format.
Defaults to normal text output (with possible colors and other pretty
printing). If a format was specified on the commandline, this format is
sent to the output. | [
"Prints",
"the",
"todos",
"in",
"the",
"right",
"format",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/commands/ListCommand.py#L134-L159 | train |
bram85/topydo | topydo/lib/TodoParser.py | parse_line | def parse_line(p_string):
"""
Parses a single line as can be encountered in a todo.txt file.
First checks whether the standard elements are present, such as priority,
creation date, completeness check and the completion date.
Then the rest of the analyzed for any occurrences of contexts, projects or
tags.
Returns an dictionary with the default values as shown below.
"""
result = {
'completed': False,
'completionDate': None,
'priority': None,
'creationDate': None,
'text': "",
'projects': [],
'contexts': [],
'tags': {},
}
completed_head = _COMPLETED_HEAD_MATCH.match(p_string)
normal_head = _NORMAL_HEAD_MATCH.match(p_string)
rest = p_string
if completed_head:
result['completed'] = True
completion_date = completed_head.group('completionDate')
try:
result['completionDate'] = date_string_to_date(completion_date)
except ValueError:
pass
creation_date = completed_head.group('creationDate')
try:
result['creationDate'] = date_string_to_date(creation_date)
except ValueError:
pass
rest = completed_head.group('rest')
elif normal_head:
result['priority'] = normal_head.group('priority')
creation_date = normal_head.group('creationDate')
try:
result['creationDate'] = date_string_to_date(creation_date)
except ValueError:
pass
rest = normal_head.group('rest')
for word in rest.split():
project = _PROJECT_MATCH.match(word)
if project:
result['projects'].append(project.group(1))
context = _CONTEXT_MATCH.match(word)
if context:
result['contexts'].append(context.group(1))
tag = _TAG_MATCH.match(word)
if tag:
tag_name = tag.group('tag')
tag_value = tag.group('value')
try:
result['tags'][tag_name].append(tag_value)
except KeyError:
result['tags'][tag_name] = [tag_value]
else:
result['text'] += word + ' '
# strip trailing space from resulting text
result['text'] = result['text'][:-1]
return result | python | def parse_line(p_string):
"""
Parses a single line as can be encountered in a todo.txt file.
First checks whether the standard elements are present, such as priority,
creation date, completeness check and the completion date.
Then the rest of the analyzed for any occurrences of contexts, projects or
tags.
Returns an dictionary with the default values as shown below.
"""
result = {
'completed': False,
'completionDate': None,
'priority': None,
'creationDate': None,
'text': "",
'projects': [],
'contexts': [],
'tags': {},
}
completed_head = _COMPLETED_HEAD_MATCH.match(p_string)
normal_head = _NORMAL_HEAD_MATCH.match(p_string)
rest = p_string
if completed_head:
result['completed'] = True
completion_date = completed_head.group('completionDate')
try:
result['completionDate'] = date_string_to_date(completion_date)
except ValueError:
pass
creation_date = completed_head.group('creationDate')
try:
result['creationDate'] = date_string_to_date(creation_date)
except ValueError:
pass
rest = completed_head.group('rest')
elif normal_head:
result['priority'] = normal_head.group('priority')
creation_date = normal_head.group('creationDate')
try:
result['creationDate'] = date_string_to_date(creation_date)
except ValueError:
pass
rest = normal_head.group('rest')
for word in rest.split():
project = _PROJECT_MATCH.match(word)
if project:
result['projects'].append(project.group(1))
context = _CONTEXT_MATCH.match(word)
if context:
result['contexts'].append(context.group(1))
tag = _TAG_MATCH.match(word)
if tag:
tag_name = tag.group('tag')
tag_value = tag.group('value')
try:
result['tags'][tag_name].append(tag_value)
except KeyError:
result['tags'][tag_name] = [tag_value]
else:
result['text'] += word + ' '
# strip trailing space from resulting text
result['text'] = result['text'][:-1]
return result | [
"def",
"parse_line",
"(",
"p_string",
")",
":",
"result",
"=",
"{",
"'completed'",
":",
"False",
",",
"'completionDate'",
":",
"None",
",",
"'priority'",
":",
"None",
",",
"'creationDate'",
":",
"None",
",",
"'text'",
":",
"\"\"",
",",
"'projects'",
":",
"[",
"]",
",",
"'contexts'",
":",
"[",
"]",
",",
"'tags'",
":",
"{",
"}",
",",
"}",
"completed_head",
"=",
"_COMPLETED_HEAD_MATCH",
".",
"match",
"(",
"p_string",
")",
"normal_head",
"=",
"_NORMAL_HEAD_MATCH",
".",
"match",
"(",
"p_string",
")",
"rest",
"=",
"p_string",
"if",
"completed_head",
":",
"result",
"[",
"'completed'",
"]",
"=",
"True",
"completion_date",
"=",
"completed_head",
".",
"group",
"(",
"'completionDate'",
")",
"try",
":",
"result",
"[",
"'completionDate'",
"]",
"=",
"date_string_to_date",
"(",
"completion_date",
")",
"except",
"ValueError",
":",
"pass",
"creation_date",
"=",
"completed_head",
".",
"group",
"(",
"'creationDate'",
")",
"try",
":",
"result",
"[",
"'creationDate'",
"]",
"=",
"date_string_to_date",
"(",
"creation_date",
")",
"except",
"ValueError",
":",
"pass",
"rest",
"=",
"completed_head",
".",
"group",
"(",
"'rest'",
")",
"elif",
"normal_head",
":",
"result",
"[",
"'priority'",
"]",
"=",
"normal_head",
".",
"group",
"(",
"'priority'",
")",
"creation_date",
"=",
"normal_head",
".",
"group",
"(",
"'creationDate'",
")",
"try",
":",
"result",
"[",
"'creationDate'",
"]",
"=",
"date_string_to_date",
"(",
"creation_date",
")",
"except",
"ValueError",
":",
"pass",
"rest",
"=",
"normal_head",
".",
"group",
"(",
"'rest'",
")",
"for",
"word",
"in",
"rest",
".",
"split",
"(",
")",
":",
"project",
"=",
"_PROJECT_MATCH",
".",
"match",
"(",
"word",
")",
"if",
"project",
":",
"result",
"[",
"'projects'",
"]",
".",
"append",
"(",
"project",
".",
"group",
"(",
"1",
")",
")",
"context",
"=",
"_CONTEXT_MATCH",
".",
"match",
"(",
"word",
")",
"if",
"context",
":",
"result",
"[",
"'contexts'",
"]",
".",
"append",
"(",
"context",
".",
"group",
"(",
"1",
")",
")",
"tag",
"=",
"_TAG_MATCH",
".",
"match",
"(",
"word",
")",
"if",
"tag",
":",
"tag_name",
"=",
"tag",
".",
"group",
"(",
"'tag'",
")",
"tag_value",
"=",
"tag",
".",
"group",
"(",
"'value'",
")",
"try",
":",
"result",
"[",
"'tags'",
"]",
"[",
"tag_name",
"]",
".",
"append",
"(",
"tag_value",
")",
"except",
"KeyError",
":",
"result",
"[",
"'tags'",
"]",
"[",
"tag_name",
"]",
"=",
"[",
"tag_value",
"]",
"else",
":",
"result",
"[",
"'text'",
"]",
"+=",
"word",
"+",
"' '",
"# strip trailing space from resulting text",
"result",
"[",
"'text'",
"]",
"=",
"result",
"[",
"'text'",
"]",
"[",
":",
"-",
"1",
"]",
"return",
"result"
] | Parses a single line as can be encountered in a todo.txt file.
First checks whether the standard elements are present, such as priority,
creation date, completeness check and the completion date.
Then the rest of the analyzed for any occurrences of contexts, projects or
tags.
Returns an dictionary with the default values as shown below. | [
"Parses",
"a",
"single",
"line",
"as",
"can",
"be",
"encountered",
"in",
"a",
"todo",
".",
"txt",
"file",
".",
"First",
"checks",
"whether",
"the",
"standard",
"elements",
"are",
"present",
"such",
"as",
"priority",
"creation",
"date",
"completeness",
"check",
"and",
"the",
"completion",
"date",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoParser.py#L41-L120 | train |
bram85/topydo | topydo/ui/prompt/PromptCompleter.py | _dates | def _dates(p_word_before_cursor):
""" Generator for date completion. """
to_absolute = lambda s: relative_date_to_date(s).isoformat()
start_value_pos = p_word_before_cursor.find(':') + 1
value = p_word_before_cursor[start_value_pos:]
for reldate in date_suggestions():
if not reldate.startswith(value):
continue
yield Completion(reldate, -len(value), display_meta=to_absolute(reldate)) | python | def _dates(p_word_before_cursor):
""" Generator for date completion. """
to_absolute = lambda s: relative_date_to_date(s).isoformat()
start_value_pos = p_word_before_cursor.find(':') + 1
value = p_word_before_cursor[start_value_pos:]
for reldate in date_suggestions():
if not reldate.startswith(value):
continue
yield Completion(reldate, -len(value), display_meta=to_absolute(reldate)) | [
"def",
"_dates",
"(",
"p_word_before_cursor",
")",
":",
"to_absolute",
"=",
"lambda",
"s",
":",
"relative_date_to_date",
"(",
"s",
")",
".",
"isoformat",
"(",
")",
"start_value_pos",
"=",
"p_word_before_cursor",
".",
"find",
"(",
"':'",
")",
"+",
"1",
"value",
"=",
"p_word_before_cursor",
"[",
"start_value_pos",
":",
"]",
"for",
"reldate",
"in",
"date_suggestions",
"(",
")",
":",
"if",
"not",
"reldate",
".",
"startswith",
"(",
"value",
")",
":",
"continue",
"yield",
"Completion",
"(",
"reldate",
",",
"-",
"len",
"(",
"value",
")",
",",
"display_meta",
"=",
"to_absolute",
"(",
"reldate",
")",
")"
] | Generator for date completion. | [
"Generator",
"for",
"date",
"completion",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/prompt/PromptCompleter.py#L31-L42 | train |
bram85/topydo | topydo/ui/columns/CompletionBoxWidget.py | CompletionBoxWidget.add_completions | def add_completions(self, p_completions):
"""
Creates proper urwid.Text widgets for all completion candidates from
p_completions list, and populates them into the items attribute.
"""
palette = PaletteItem.MARKED
for completion in p_completions:
width = len(completion)
if width > self.min_width:
self.min_width = width
w = urwid.Text(completion)
self.items.append(urwid.AttrMap(w, None, focus_map=palette))
self.items.set_focus(0) | python | def add_completions(self, p_completions):
"""
Creates proper urwid.Text widgets for all completion candidates from
p_completions list, and populates them into the items attribute.
"""
palette = PaletteItem.MARKED
for completion in p_completions:
width = len(completion)
if width > self.min_width:
self.min_width = width
w = urwid.Text(completion)
self.items.append(urwid.AttrMap(w, None, focus_map=palette))
self.items.set_focus(0) | [
"def",
"add_completions",
"(",
"self",
",",
"p_completions",
")",
":",
"palette",
"=",
"PaletteItem",
".",
"MARKED",
"for",
"completion",
"in",
"p_completions",
":",
"width",
"=",
"len",
"(",
"completion",
")",
"if",
"width",
">",
"self",
".",
"min_width",
":",
"self",
".",
"min_width",
"=",
"width",
"w",
"=",
"urwid",
".",
"Text",
"(",
"completion",
")",
"self",
".",
"items",
".",
"append",
"(",
"urwid",
".",
"AttrMap",
"(",
"w",
",",
"None",
",",
"focus_map",
"=",
"palette",
")",
")",
"self",
".",
"items",
".",
"set_focus",
"(",
"0",
")"
] | Creates proper urwid.Text widgets for all completion candidates from
p_completions list, and populates them into the items attribute. | [
"Creates",
"proper",
"urwid",
".",
"Text",
"widgets",
"for",
"all",
"completion",
"candidates",
"from",
"p_completions",
"list",
"and",
"populates",
"them",
"into",
"the",
"items",
"attribute",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/CompletionBoxWidget.py#L44-L56 | train |
bram85/topydo | topydo/lib/View.py | View._apply_filters | def _apply_filters(self, p_todos):
""" Applies the filters to the list of todo items. """
result = p_todos
for _filter in sorted(self._filters, key=lambda f: f.order):
result = _filter.filter(result)
return result | python | def _apply_filters(self, p_todos):
""" Applies the filters to the list of todo items. """
result = p_todos
for _filter in sorted(self._filters, key=lambda f: f.order):
result = _filter.filter(result)
return result | [
"def",
"_apply_filters",
"(",
"self",
",",
"p_todos",
")",
":",
"result",
"=",
"p_todos",
"for",
"_filter",
"in",
"sorted",
"(",
"self",
".",
"_filters",
",",
"key",
"=",
"lambda",
"f",
":",
"f",
".",
"order",
")",
":",
"result",
"=",
"_filter",
".",
"filter",
"(",
"result",
")",
"return",
"result"
] | Applies the filters to the list of todo items. | [
"Applies",
"the",
"filters",
"to",
"the",
"list",
"of",
"todo",
"items",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/View.py#L32-L39 | train |
bram85/topydo | topydo/lib/View.py | View.todos | def todos(self):
""" Returns a sorted and filtered list of todos in this view. """
result = self._sorter.sort(self.todolist.todos())
return self._apply_filters(result) | python | def todos(self):
""" Returns a sorted and filtered list of todos in this view. """
result = self._sorter.sort(self.todolist.todos())
return self._apply_filters(result) | [
"def",
"todos",
"(",
"self",
")",
":",
"result",
"=",
"self",
".",
"_sorter",
".",
"sort",
"(",
"self",
".",
"todolist",
".",
"todos",
"(",
")",
")",
"return",
"self",
".",
"_apply_filters",
"(",
"result",
")"
] | Returns a sorted and filtered list of todos in this view. | [
"Returns",
"a",
"sorted",
"and",
"filtered",
"list",
"of",
"todos",
"in",
"this",
"view",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/View.py#L42-L45 | train |
bram85/topydo | topydo/commands/DoCommand.py | DoCommand.execute_specific | def execute_specific(self, p_todo):
""" Actions specific to this command. """
self._handle_recurrence(p_todo)
self.execute_specific_core(p_todo)
printer = PrettyPrinter()
self.out(self.prefix() + printer.print_todo(p_todo)) | python | def execute_specific(self, p_todo):
""" Actions specific to this command. """
self._handle_recurrence(p_todo)
self.execute_specific_core(p_todo)
printer = PrettyPrinter()
self.out(self.prefix() + printer.print_todo(p_todo)) | [
"def",
"execute_specific",
"(",
"self",
",",
"p_todo",
")",
":",
"self",
".",
"_handle_recurrence",
"(",
"p_todo",
")",
"self",
".",
"execute_specific_core",
"(",
"p_todo",
")",
"printer",
"=",
"PrettyPrinter",
"(",
")",
"self",
".",
"out",
"(",
"self",
".",
"prefix",
"(",
")",
"+",
"printer",
".",
"print_todo",
"(",
"p_todo",
")",
")"
] | Actions specific to this command. | [
"Actions",
"specific",
"to",
"this",
"command",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/commands/DoCommand.py#L81-L87 | train |
bram85/topydo | topydo/lib/Utils.py | date_string_to_date | def date_string_to_date(p_date):
"""
Given a date in YYYY-MM-DD, returns a Python date object. Throws a
ValueError if the date is invalid.
"""
result = None
if p_date:
parsed_date = re.match(r'(\d{4})-(\d{2})-(\d{2})', p_date)
if parsed_date:
result = date(
int(parsed_date.group(1)), # year
int(parsed_date.group(2)), # month
int(parsed_date.group(3)) # day
)
else:
raise ValueError
return result | python | def date_string_to_date(p_date):
"""
Given a date in YYYY-MM-DD, returns a Python date object. Throws a
ValueError if the date is invalid.
"""
result = None
if p_date:
parsed_date = re.match(r'(\d{4})-(\d{2})-(\d{2})', p_date)
if parsed_date:
result = date(
int(parsed_date.group(1)), # year
int(parsed_date.group(2)), # month
int(parsed_date.group(3)) # day
)
else:
raise ValueError
return result | [
"def",
"date_string_to_date",
"(",
"p_date",
")",
":",
"result",
"=",
"None",
"if",
"p_date",
":",
"parsed_date",
"=",
"re",
".",
"match",
"(",
"r'(\\d{4})-(\\d{2})-(\\d{2})'",
",",
"p_date",
")",
"if",
"parsed_date",
":",
"result",
"=",
"date",
"(",
"int",
"(",
"parsed_date",
".",
"group",
"(",
"1",
")",
")",
",",
"# year",
"int",
"(",
"parsed_date",
".",
"group",
"(",
"2",
")",
")",
",",
"# month",
"int",
"(",
"parsed_date",
".",
"group",
"(",
"3",
")",
")",
"# day",
")",
"else",
":",
"raise",
"ValueError",
"return",
"result"
] | Given a date in YYYY-MM-DD, returns a Python date object. Throws a
ValueError if the date is invalid. | [
"Given",
"a",
"date",
"in",
"YYYY",
"-",
"MM",
"-",
"DD",
"returns",
"a",
"Python",
"date",
"object",
".",
"Throws",
"a",
"ValueError",
"if",
"the",
"date",
"is",
"invalid",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Utils.py#L28-L46 | train |
bram85/topydo | topydo/lib/Utils.py | get_terminal_size | def get_terminal_size(p_getter=None):
"""
Try to determine terminal size at run time. If that is not possible,
returns the default size of 80x24.
By default, the size is determined with provided get_terminal_size by
shutil. Sometimes an UI may want to specify the desired width, then it can
provide a getter that returns a named tuple (columns, lines) with the size.
"""
try:
return get_terminal_size.getter()
except AttributeError:
if p_getter:
get_terminal_size.getter = p_getter
else:
def inner():
try:
# shutil.get_terminal_size was added to the standard
# library in Python 3.3
try:
from shutil import get_terminal_size as _get_terminal_size # pylint: disable=no-name-in-module
except ImportError:
from backports.shutil_get_terminal_size import get_terminal_size as _get_terminal_size # pylint: disable=import-error
size = _get_terminal_size()
except ValueError:
# This can result from the 'underlying buffer being detached', which
# occurs during running the unittest on Windows (but not on Linux?)
terminal_size = namedtuple('Terminal_Size', 'columns lines')
size = terminal_size(80, 24)
return size
get_terminal_size.getter = inner
return get_terminal_size.getter() | python | def get_terminal_size(p_getter=None):
"""
Try to determine terminal size at run time. If that is not possible,
returns the default size of 80x24.
By default, the size is determined with provided get_terminal_size by
shutil. Sometimes an UI may want to specify the desired width, then it can
provide a getter that returns a named tuple (columns, lines) with the size.
"""
try:
return get_terminal_size.getter()
except AttributeError:
if p_getter:
get_terminal_size.getter = p_getter
else:
def inner():
try:
# shutil.get_terminal_size was added to the standard
# library in Python 3.3
try:
from shutil import get_terminal_size as _get_terminal_size # pylint: disable=no-name-in-module
except ImportError:
from backports.shutil_get_terminal_size import get_terminal_size as _get_terminal_size # pylint: disable=import-error
size = _get_terminal_size()
except ValueError:
# This can result from the 'underlying buffer being detached', which
# occurs during running the unittest on Windows (but not on Linux?)
terminal_size = namedtuple('Terminal_Size', 'columns lines')
size = terminal_size(80, 24)
return size
get_terminal_size.getter = inner
return get_terminal_size.getter() | [
"def",
"get_terminal_size",
"(",
"p_getter",
"=",
"None",
")",
":",
"try",
":",
"return",
"get_terminal_size",
".",
"getter",
"(",
")",
"except",
"AttributeError",
":",
"if",
"p_getter",
":",
"get_terminal_size",
".",
"getter",
"=",
"p_getter",
"else",
":",
"def",
"inner",
"(",
")",
":",
"try",
":",
"# shutil.get_terminal_size was added to the standard",
"# library in Python 3.3",
"try",
":",
"from",
"shutil",
"import",
"get_terminal_size",
"as",
"_get_terminal_size",
"# pylint: disable=no-name-in-module",
"except",
"ImportError",
":",
"from",
"backports",
".",
"shutil_get_terminal_size",
"import",
"get_terminal_size",
"as",
"_get_terminal_size",
"# pylint: disable=import-error",
"size",
"=",
"_get_terminal_size",
"(",
")",
"except",
"ValueError",
":",
"# This can result from the 'underlying buffer being detached', which",
"# occurs during running the unittest on Windows (but not on Linux?)",
"terminal_size",
"=",
"namedtuple",
"(",
"'Terminal_Size'",
",",
"'columns lines'",
")",
"size",
"=",
"terminal_size",
"(",
"80",
",",
"24",
")",
"return",
"size",
"get_terminal_size",
".",
"getter",
"=",
"inner",
"return",
"get_terminal_size",
".",
"getter",
"(",
")"
] | Try to determine terminal size at run time. If that is not possible,
returns the default size of 80x24.
By default, the size is determined with provided get_terminal_size by
shutil. Sometimes an UI may want to specify the desired width, then it can
provide a getter that returns a named tuple (columns, lines) with the size. | [
"Try",
"to",
"determine",
"terminal",
"size",
"at",
"run",
"time",
".",
"If",
"that",
"is",
"not",
"possible",
"returns",
"the",
"default",
"size",
"of",
"80x24",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Utils.py#L59-L95 | train |
bram85/topydo | topydo/lib/Utils.py | translate_key_to_config | def translate_key_to_config(p_key):
"""
Translates urwid key event to form understandable by topydo config parser.
"""
if len(p_key) > 1:
key = p_key.capitalize()
if key.startswith('Ctrl') or key.startswith('Meta'):
key = key[0] + '-' + key[5:]
key = '<' + key + '>'
else:
key = p_key
return key | python | def translate_key_to_config(p_key):
"""
Translates urwid key event to form understandable by topydo config parser.
"""
if len(p_key) > 1:
key = p_key.capitalize()
if key.startswith('Ctrl') or key.startswith('Meta'):
key = key[0] + '-' + key[5:]
key = '<' + key + '>'
else:
key = p_key
return key | [
"def",
"translate_key_to_config",
"(",
"p_key",
")",
":",
"if",
"len",
"(",
"p_key",
")",
">",
"1",
":",
"key",
"=",
"p_key",
".",
"capitalize",
"(",
")",
"if",
"key",
".",
"startswith",
"(",
"'Ctrl'",
")",
"or",
"key",
".",
"startswith",
"(",
"'Meta'",
")",
":",
"key",
"=",
"key",
"[",
"0",
"]",
"+",
"'-'",
"+",
"key",
"[",
"5",
":",
"]",
"key",
"=",
"'<'",
"+",
"key",
"+",
"'>'",
"else",
":",
"key",
"=",
"p_key",
"return",
"key"
] | Translates urwid key event to form understandable by topydo config parser. | [
"Translates",
"urwid",
"key",
"event",
"to",
"form",
"understandable",
"by",
"topydo",
"config",
"parser",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Utils.py#L98-L110 | train |
bram85/topydo | topydo/lib/Utils.py | humanize_date | def humanize_date(p_datetime):
""" Returns a relative date string from a datetime object. """
now = arrow.now()
_date = now.replace(day=p_datetime.day, month=p_datetime.month, year=p_datetime.year)
return _date.humanize(now).replace('just now', 'today') | python | def humanize_date(p_datetime):
""" Returns a relative date string from a datetime object. """
now = arrow.now()
_date = now.replace(day=p_datetime.day, month=p_datetime.month, year=p_datetime.year)
return _date.humanize(now).replace('just now', 'today') | [
"def",
"humanize_date",
"(",
"p_datetime",
")",
":",
"now",
"=",
"arrow",
".",
"now",
"(",
")",
"_date",
"=",
"now",
".",
"replace",
"(",
"day",
"=",
"p_datetime",
".",
"day",
",",
"month",
"=",
"p_datetime",
".",
"month",
",",
"year",
"=",
"p_datetime",
".",
"year",
")",
"return",
"_date",
".",
"humanize",
"(",
"now",
")",
".",
"replace",
"(",
"'just now'",
",",
"'today'",
")"
] | Returns a relative date string from a datetime object. | [
"Returns",
"a",
"relative",
"date",
"string",
"from",
"a",
"datetime",
"object",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Utils.py#L112-L116 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._check_id_validity | def _check_id_validity(self, p_ids):
"""
Checks if there are any invalid todo IDs in p_ids list.
Returns proper error message if any ID is invalid and None otherwise.
"""
errors = []
valid_ids = self.todolist.ids()
if len(p_ids) == 0:
errors.append('No todo item was selected')
else:
errors = ["Invalid todo ID: {}".format(todo_id)
for todo_id in p_ids - valid_ids]
errors = '\n'.join(errors) if errors else None
return errors | python | def _check_id_validity(self, p_ids):
"""
Checks if there are any invalid todo IDs in p_ids list.
Returns proper error message if any ID is invalid and None otherwise.
"""
errors = []
valid_ids = self.todolist.ids()
if len(p_ids) == 0:
errors.append('No todo item was selected')
else:
errors = ["Invalid todo ID: {}".format(todo_id)
for todo_id in p_ids - valid_ids]
errors = '\n'.join(errors) if errors else None
return errors | [
"def",
"_check_id_validity",
"(",
"self",
",",
"p_ids",
")",
":",
"errors",
"=",
"[",
"]",
"valid_ids",
"=",
"self",
".",
"todolist",
".",
"ids",
"(",
")",
"if",
"len",
"(",
"p_ids",
")",
"==",
"0",
":",
"errors",
".",
"append",
"(",
"'No todo item was selected'",
")",
"else",
":",
"errors",
"=",
"[",
"\"Invalid todo ID: {}\"",
".",
"format",
"(",
"todo_id",
")",
"for",
"todo_id",
"in",
"p_ids",
"-",
"valid_ids",
"]",
"errors",
"=",
"'\\n'",
".",
"join",
"(",
"errors",
")",
"if",
"errors",
"else",
"None",
"return",
"errors"
] | Checks if there are any invalid todo IDs in p_ids list.
Returns proper error message if any ID is invalid and None otherwise. | [
"Checks",
"if",
"there",
"are",
"any",
"invalid",
"todo",
"IDs",
"in",
"p_ids",
"list",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L286-L302 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._execute_handler | def _execute_handler(self, p_command, p_todo_id=None, p_output=None):
"""
Executes a command, given as a string.
"""
p_output = p_output or self._output
self._console_visible = False
self._last_cmd = (p_command, p_output == self._output)
try:
p_command = shlex.split(p_command)
except ValueError as verr:
self._print_to_console('Error: ' + str(verr))
return
try:
subcommand, args = get_subcommand(p_command)
except ConfigError as cerr:
self._print_to_console(
'Error: {}. Check your aliases configuration.'.format(cerr))
return
if subcommand is None:
self._print_to_console(GENERIC_HELP)
return
env_args = (self.todolist, p_output, self._output, self._input)
ids = None
if '{}' in args:
if self._has_marked_todos():
ids = self.marked_todos
else:
ids = {p_todo_id} if p_todo_id else set()
invalid_ids = self._check_id_validity(ids)
if invalid_ids:
self._print_to_console('Error: ' + invalid_ids)
return
transaction = Transaction(subcommand, env_args, ids)
transaction.prepare(args)
label = transaction.label
self._backup(subcommand, p_label=label)
try:
if transaction.execute():
post_archive_action = transaction.execute_post_archive_actions
self._post_archive_action = post_archive_action
self._post_execute()
else:
self._rollback()
except TypeError:
# TODO: show error message
pass | python | def _execute_handler(self, p_command, p_todo_id=None, p_output=None):
"""
Executes a command, given as a string.
"""
p_output = p_output or self._output
self._console_visible = False
self._last_cmd = (p_command, p_output == self._output)
try:
p_command = shlex.split(p_command)
except ValueError as verr:
self._print_to_console('Error: ' + str(verr))
return
try:
subcommand, args = get_subcommand(p_command)
except ConfigError as cerr:
self._print_to_console(
'Error: {}. Check your aliases configuration.'.format(cerr))
return
if subcommand is None:
self._print_to_console(GENERIC_HELP)
return
env_args = (self.todolist, p_output, self._output, self._input)
ids = None
if '{}' in args:
if self._has_marked_todos():
ids = self.marked_todos
else:
ids = {p_todo_id} if p_todo_id else set()
invalid_ids = self._check_id_validity(ids)
if invalid_ids:
self._print_to_console('Error: ' + invalid_ids)
return
transaction = Transaction(subcommand, env_args, ids)
transaction.prepare(args)
label = transaction.label
self._backup(subcommand, p_label=label)
try:
if transaction.execute():
post_archive_action = transaction.execute_post_archive_actions
self._post_archive_action = post_archive_action
self._post_execute()
else:
self._rollback()
except TypeError:
# TODO: show error message
pass | [
"def",
"_execute_handler",
"(",
"self",
",",
"p_command",
",",
"p_todo_id",
"=",
"None",
",",
"p_output",
"=",
"None",
")",
":",
"p_output",
"=",
"p_output",
"or",
"self",
".",
"_output",
"self",
".",
"_console_visible",
"=",
"False",
"self",
".",
"_last_cmd",
"=",
"(",
"p_command",
",",
"p_output",
"==",
"self",
".",
"_output",
")",
"try",
":",
"p_command",
"=",
"shlex",
".",
"split",
"(",
"p_command",
")",
"except",
"ValueError",
"as",
"verr",
":",
"self",
".",
"_print_to_console",
"(",
"'Error: '",
"+",
"str",
"(",
"verr",
")",
")",
"return",
"try",
":",
"subcommand",
",",
"args",
"=",
"get_subcommand",
"(",
"p_command",
")",
"except",
"ConfigError",
"as",
"cerr",
":",
"self",
".",
"_print_to_console",
"(",
"'Error: {}. Check your aliases configuration.'",
".",
"format",
"(",
"cerr",
")",
")",
"return",
"if",
"subcommand",
"is",
"None",
":",
"self",
".",
"_print_to_console",
"(",
"GENERIC_HELP",
")",
"return",
"env_args",
"=",
"(",
"self",
".",
"todolist",
",",
"p_output",
",",
"self",
".",
"_output",
",",
"self",
".",
"_input",
")",
"ids",
"=",
"None",
"if",
"'{}'",
"in",
"args",
":",
"if",
"self",
".",
"_has_marked_todos",
"(",
")",
":",
"ids",
"=",
"self",
".",
"marked_todos",
"else",
":",
"ids",
"=",
"{",
"p_todo_id",
"}",
"if",
"p_todo_id",
"else",
"set",
"(",
")",
"invalid_ids",
"=",
"self",
".",
"_check_id_validity",
"(",
"ids",
")",
"if",
"invalid_ids",
":",
"self",
".",
"_print_to_console",
"(",
"'Error: '",
"+",
"invalid_ids",
")",
"return",
"transaction",
"=",
"Transaction",
"(",
"subcommand",
",",
"env_args",
",",
"ids",
")",
"transaction",
".",
"prepare",
"(",
"args",
")",
"label",
"=",
"transaction",
".",
"label",
"self",
".",
"_backup",
"(",
"subcommand",
",",
"p_label",
"=",
"label",
")",
"try",
":",
"if",
"transaction",
".",
"execute",
"(",
")",
":",
"post_archive_action",
"=",
"transaction",
".",
"execute_post_archive_actions",
"self",
".",
"_post_archive_action",
"=",
"post_archive_action",
"self",
".",
"_post_execute",
"(",
")",
"else",
":",
"self",
".",
"_rollback",
"(",
")",
"except",
"TypeError",
":",
"# TODO: show error message",
"pass"
] | Executes a command, given as a string. | [
"Executes",
"a",
"command",
"given",
"as",
"a",
"string",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L304-L359 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._viewdata_to_view | def _viewdata_to_view(self, p_data):
"""
Converts a dictionary describing a view to an actual UIView instance.
"""
sorter = Sorter(p_data['sortexpr'], p_data['groupexpr'])
filters = []
if not p_data['show_all']:
filters.append(DependencyFilter(self.todolist))
filters.append(RelevanceFilter())
filters.append(HiddenTagFilter())
filters += get_filter_list(p_data['filterexpr'].split())
return UIView(sorter, filters, self.todolist, p_data) | python | def _viewdata_to_view(self, p_data):
"""
Converts a dictionary describing a view to an actual UIView instance.
"""
sorter = Sorter(p_data['sortexpr'], p_data['groupexpr'])
filters = []
if not p_data['show_all']:
filters.append(DependencyFilter(self.todolist))
filters.append(RelevanceFilter())
filters.append(HiddenTagFilter())
filters += get_filter_list(p_data['filterexpr'].split())
return UIView(sorter, filters, self.todolist, p_data) | [
"def",
"_viewdata_to_view",
"(",
"self",
",",
"p_data",
")",
":",
"sorter",
"=",
"Sorter",
"(",
"p_data",
"[",
"'sortexpr'",
"]",
",",
"p_data",
"[",
"'groupexpr'",
"]",
")",
"filters",
"=",
"[",
"]",
"if",
"not",
"p_data",
"[",
"'show_all'",
"]",
":",
"filters",
".",
"append",
"(",
"DependencyFilter",
"(",
"self",
".",
"todolist",
")",
")",
"filters",
".",
"append",
"(",
"RelevanceFilter",
"(",
")",
")",
"filters",
".",
"append",
"(",
"HiddenTagFilter",
"(",
")",
")",
"filters",
"+=",
"get_filter_list",
"(",
"p_data",
"[",
"'filterexpr'",
"]",
".",
"split",
"(",
")",
")",
"return",
"UIView",
"(",
"sorter",
",",
"filters",
",",
"self",
".",
"todolist",
",",
"p_data",
")"
] | Converts a dictionary describing a view to an actual UIView instance. | [
"Converts",
"a",
"dictionary",
"describing",
"a",
"view",
"to",
"an",
"actual",
"UIView",
"instance",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L479-L493 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._update_view | def _update_view(self, p_data):
""" Creates a view from the data entered in the view widget. """
view = self._viewdata_to_view(p_data)
if self.column_mode == _APPEND_COLUMN or self.column_mode == _COPY_COLUMN:
self._add_column(view)
elif self.column_mode == _INSERT_COLUMN:
self._add_column(view, self.columns.focus_position)
elif self.column_mode == _EDIT_COLUMN:
current_column = self.columns.focus
current_column.title = p_data['title']
current_column.view = view
self._viewwidget_visible = False
self._blur_commandline() | python | def _update_view(self, p_data):
""" Creates a view from the data entered in the view widget. """
view = self._viewdata_to_view(p_data)
if self.column_mode == _APPEND_COLUMN or self.column_mode == _COPY_COLUMN:
self._add_column(view)
elif self.column_mode == _INSERT_COLUMN:
self._add_column(view, self.columns.focus_position)
elif self.column_mode == _EDIT_COLUMN:
current_column = self.columns.focus
current_column.title = p_data['title']
current_column.view = view
self._viewwidget_visible = False
self._blur_commandline() | [
"def",
"_update_view",
"(",
"self",
",",
"p_data",
")",
":",
"view",
"=",
"self",
".",
"_viewdata_to_view",
"(",
"p_data",
")",
"if",
"self",
".",
"column_mode",
"==",
"_APPEND_COLUMN",
"or",
"self",
".",
"column_mode",
"==",
"_COPY_COLUMN",
":",
"self",
".",
"_add_column",
"(",
"view",
")",
"elif",
"self",
".",
"column_mode",
"==",
"_INSERT_COLUMN",
":",
"self",
".",
"_add_column",
"(",
"view",
",",
"self",
".",
"columns",
".",
"focus_position",
")",
"elif",
"self",
".",
"column_mode",
"==",
"_EDIT_COLUMN",
":",
"current_column",
"=",
"self",
".",
"columns",
".",
"focus",
"current_column",
".",
"title",
"=",
"p_data",
"[",
"'title'",
"]",
"current_column",
".",
"view",
"=",
"view",
"self",
".",
"_viewwidget_visible",
"=",
"False",
"self",
".",
"_blur_commandline",
"(",
")"
] | Creates a view from the data entered in the view widget. | [
"Creates",
"a",
"view",
"from",
"the",
"data",
"entered",
"in",
"the",
"view",
"widget",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L495-L510 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._add_column | def _add_column(self, p_view, p_pos=None):
"""
Given an UIView, adds a new column widget with the todos in that view.
When no position is given, it is added to the end, otherwise inserted
before that position.
"""
def execute_silent(p_cmd, p_todo_id=None):
self._execute_handler(p_cmd, p_todo_id, lambda _: None)
todolist = TodoListWidget(p_view, p_view.data['title'], self.keymap)
urwid.connect_signal(todolist, 'execute_command_silent',
execute_silent)
urwid.connect_signal(todolist, 'execute_command', self._execute_handler)
urwid.connect_signal(todolist, 'repeat_cmd', self._repeat_last_cmd)
urwid.connect_signal(todolist, 'refresh', self.mainloop.screen.clear)
urwid.connect_signal(todolist, 'add_pending_action', self._set_alarm)
urwid.connect_signal(todolist, 'remove_pending_action', self._remove_alarm)
urwid.connect_signal(todolist, 'column_action', self._column_action_handler)
urwid.connect_signal(todolist, 'show_keystate', self._print_keystate)
urwid.connect_signal(todolist, 'toggle_mark',
self._process_mark_toggle)
options = self.columns.options(
width_type='given',
width_amount=config().column_width(),
box_widget=True
)
item = (todolist, options)
if p_pos == None:
p_pos = len(self.columns.contents)
self.columns.contents.insert(p_pos, item)
self.columns.focus_position = p_pos
self._blur_commandline() | python | def _add_column(self, p_view, p_pos=None):
"""
Given an UIView, adds a new column widget with the todos in that view.
When no position is given, it is added to the end, otherwise inserted
before that position.
"""
def execute_silent(p_cmd, p_todo_id=None):
self._execute_handler(p_cmd, p_todo_id, lambda _: None)
todolist = TodoListWidget(p_view, p_view.data['title'], self.keymap)
urwid.connect_signal(todolist, 'execute_command_silent',
execute_silent)
urwid.connect_signal(todolist, 'execute_command', self._execute_handler)
urwid.connect_signal(todolist, 'repeat_cmd', self._repeat_last_cmd)
urwid.connect_signal(todolist, 'refresh', self.mainloop.screen.clear)
urwid.connect_signal(todolist, 'add_pending_action', self._set_alarm)
urwid.connect_signal(todolist, 'remove_pending_action', self._remove_alarm)
urwid.connect_signal(todolist, 'column_action', self._column_action_handler)
urwid.connect_signal(todolist, 'show_keystate', self._print_keystate)
urwid.connect_signal(todolist, 'toggle_mark',
self._process_mark_toggle)
options = self.columns.options(
width_type='given',
width_amount=config().column_width(),
box_widget=True
)
item = (todolist, options)
if p_pos == None:
p_pos = len(self.columns.contents)
self.columns.contents.insert(p_pos, item)
self.columns.focus_position = p_pos
self._blur_commandline() | [
"def",
"_add_column",
"(",
"self",
",",
"p_view",
",",
"p_pos",
"=",
"None",
")",
":",
"def",
"execute_silent",
"(",
"p_cmd",
",",
"p_todo_id",
"=",
"None",
")",
":",
"self",
".",
"_execute_handler",
"(",
"p_cmd",
",",
"p_todo_id",
",",
"lambda",
"_",
":",
"None",
")",
"todolist",
"=",
"TodoListWidget",
"(",
"p_view",
",",
"p_view",
".",
"data",
"[",
"'title'",
"]",
",",
"self",
".",
"keymap",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'execute_command_silent'",
",",
"execute_silent",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'execute_command'",
",",
"self",
".",
"_execute_handler",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'repeat_cmd'",
",",
"self",
".",
"_repeat_last_cmd",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'refresh'",
",",
"self",
".",
"mainloop",
".",
"screen",
".",
"clear",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'add_pending_action'",
",",
"self",
".",
"_set_alarm",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'remove_pending_action'",
",",
"self",
".",
"_remove_alarm",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'column_action'",
",",
"self",
".",
"_column_action_handler",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'show_keystate'",
",",
"self",
".",
"_print_keystate",
")",
"urwid",
".",
"connect_signal",
"(",
"todolist",
",",
"'toggle_mark'",
",",
"self",
".",
"_process_mark_toggle",
")",
"options",
"=",
"self",
".",
"columns",
".",
"options",
"(",
"width_type",
"=",
"'given'",
",",
"width_amount",
"=",
"config",
"(",
")",
".",
"column_width",
"(",
")",
",",
"box_widget",
"=",
"True",
")",
"item",
"=",
"(",
"todolist",
",",
"options",
")",
"if",
"p_pos",
"==",
"None",
":",
"p_pos",
"=",
"len",
"(",
"self",
".",
"columns",
".",
"contents",
")",
"self",
".",
"columns",
".",
"contents",
".",
"insert",
"(",
"p_pos",
",",
"item",
")",
"self",
".",
"columns",
".",
"focus_position",
"=",
"p_pos",
"self",
".",
"_blur_commandline",
"(",
")"
] | Given an UIView, adds a new column widget with the todos in that view.
When no position is given, it is added to the end, otherwise inserted
before that position. | [
"Given",
"an",
"UIView",
"adds",
"a",
"new",
"column",
"widget",
"with",
"the",
"todos",
"in",
"that",
"view",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L512-L549 | train |
bram85/topydo | topydo/ui/columns/Main.py | UIApplication._process_mark_toggle | def _process_mark_toggle(self, p_todo_id, p_force=None):
"""
Adds p_todo_id to marked_todos attribute and returns True if p_todo_id
is not already marked. Removes p_todo_id from marked_todos and returns
False otherwise.
p_force parameter accepting 'mark' or 'unmark' values, if set, can force
desired action without checking p_todo_id presence in marked_todos.
"""
if p_force in ['mark', 'unmark']:
action = p_force
else:
action = 'mark' if p_todo_id not in self.marked_todos else 'unmark'
if action == 'mark':
self.marked_todos.add(p_todo_id)
return True
else:
self.marked_todos.remove(p_todo_id)
return False | python | def _process_mark_toggle(self, p_todo_id, p_force=None):
"""
Adds p_todo_id to marked_todos attribute and returns True if p_todo_id
is not already marked. Removes p_todo_id from marked_todos and returns
False otherwise.
p_force parameter accepting 'mark' or 'unmark' values, if set, can force
desired action without checking p_todo_id presence in marked_todos.
"""
if p_force in ['mark', 'unmark']:
action = p_force
else:
action = 'mark' if p_todo_id not in self.marked_todos else 'unmark'
if action == 'mark':
self.marked_todos.add(p_todo_id)
return True
else:
self.marked_todos.remove(p_todo_id)
return False | [
"def",
"_process_mark_toggle",
"(",
"self",
",",
"p_todo_id",
",",
"p_force",
"=",
"None",
")",
":",
"if",
"p_force",
"in",
"[",
"'mark'",
",",
"'unmark'",
"]",
":",
"action",
"=",
"p_force",
"else",
":",
"action",
"=",
"'mark'",
"if",
"p_todo_id",
"not",
"in",
"self",
".",
"marked_todos",
"else",
"'unmark'",
"if",
"action",
"==",
"'mark'",
":",
"self",
".",
"marked_todos",
".",
"add",
"(",
"p_todo_id",
")",
"return",
"True",
"else",
":",
"self",
".",
"marked_todos",
".",
"remove",
"(",
"p_todo_id",
")",
"return",
"False"
] | Adds p_todo_id to marked_todos attribute and returns True if p_todo_id
is not already marked. Removes p_todo_id from marked_todos and returns
False otherwise.
p_force parameter accepting 'mark' or 'unmark' values, if set, can force
desired action without checking p_todo_id presence in marked_todos. | [
"Adds",
"p_todo_id",
"to",
"marked_todos",
"attribute",
"and",
"returns",
"True",
"if",
"p_todo_id",
"is",
"not",
"already",
"marked",
".",
"Removes",
"p_todo_id",
"from",
"marked_todos",
"and",
"returns",
"False",
"otherwise",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/Main.py#L683-L702 | train |
bram85/topydo | topydo/ui/columns/ViewWidget.py | ViewWidget.reset | def reset(self):
""" Resets the form. """
self.titleedit.set_edit_text("")
self.sortedit.set_edit_text("")
self.filteredit.set_edit_text("")
self.relevantradio.set_state(True)
self.pile.focus_item = 0 | python | def reset(self):
""" Resets the form. """
self.titleedit.set_edit_text("")
self.sortedit.set_edit_text("")
self.filteredit.set_edit_text("")
self.relevantradio.set_state(True)
self.pile.focus_item = 0 | [
"def",
"reset",
"(",
"self",
")",
":",
"self",
".",
"titleedit",
".",
"set_edit_text",
"(",
"\"\"",
")",
"self",
".",
"sortedit",
".",
"set_edit_text",
"(",
"\"\"",
")",
"self",
".",
"filteredit",
".",
"set_edit_text",
"(",
"\"\"",
")",
"self",
".",
"relevantradio",
".",
"set_state",
"(",
"True",
")",
"self",
".",
"pile",
".",
"focus_item",
"=",
"0"
] | Resets the form. | [
"Resets",
"the",
"form",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/ViewWidget.py#L71-L77 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.has_tag | def has_tag(self, p_key, p_value=""):
"""
Returns true when there is at least one tag with the given key. If a
value is passed, it will only return true when there exists a tag with
the given key-value combination.
"""
tags = self.fields['tags']
return p_key in tags and (p_value == "" or p_value in tags[p_key]) | python | def has_tag(self, p_key, p_value=""):
"""
Returns true when there is at least one tag with the given key. If a
value is passed, it will only return true when there exists a tag with
the given key-value combination.
"""
tags = self.fields['tags']
return p_key in tags and (p_value == "" or p_value in tags[p_key]) | [
"def",
"has_tag",
"(",
"self",
",",
"p_key",
",",
"p_value",
"=",
"\"\"",
")",
":",
"tags",
"=",
"self",
".",
"fields",
"[",
"'tags'",
"]",
"return",
"p_key",
"in",
"tags",
"and",
"(",
"p_value",
"==",
"\"\"",
"or",
"p_value",
"in",
"tags",
"[",
"p_key",
"]",
")"
] | Returns true when there is at least one tag with the given key. If a
value is passed, it will only return true when there exists a tag with
the given key-value combination. | [
"Returns",
"true",
"when",
"there",
"is",
"at",
"least",
"one",
"tag",
"with",
"the",
"given",
"key",
".",
"If",
"a",
"value",
"is",
"passed",
"it",
"will",
"only",
"return",
"true",
"when",
"there",
"exists",
"a",
"tag",
"with",
"the",
"given",
"key",
"-",
"value",
"combination",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L60-L67 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase._remove_tag_helper | def _remove_tag_helper(self, p_key, p_value):
"""
Removes a tag from the internal todo dictionary. Only those instances
with the given value are removed. If the value is empty, all tags with
the given key are removed.
"""
tags = self.fields['tags']
try:
tags[p_key] = [t for t in tags[p_key] if p_value != "" and t != p_value]
if len(tags[p_key]) == 0:
del tags[p_key]
except KeyError:
pass | python | def _remove_tag_helper(self, p_key, p_value):
"""
Removes a tag from the internal todo dictionary. Only those instances
with the given value are removed. If the value is empty, all tags with
the given key are removed.
"""
tags = self.fields['tags']
try:
tags[p_key] = [t for t in tags[p_key] if p_value != "" and t != p_value]
if len(tags[p_key]) == 0:
del tags[p_key]
except KeyError:
pass | [
"def",
"_remove_tag_helper",
"(",
"self",
",",
"p_key",
",",
"p_value",
")",
":",
"tags",
"=",
"self",
".",
"fields",
"[",
"'tags'",
"]",
"try",
":",
"tags",
"[",
"p_key",
"]",
"=",
"[",
"t",
"for",
"t",
"in",
"tags",
"[",
"p_key",
"]",
"if",
"p_value",
"!=",
"\"\"",
"and",
"t",
"!=",
"p_value",
"]",
"if",
"len",
"(",
"tags",
"[",
"p_key",
"]",
")",
"==",
"0",
":",
"del",
"tags",
"[",
"p_key",
"]",
"except",
"KeyError",
":",
"pass"
] | Removes a tag from the internal todo dictionary. Only those instances
with the given value are removed. If the value is empty, all tags with
the given key are removed. | [
"Removes",
"a",
"tag",
"from",
"the",
"internal",
"todo",
"dictionary",
".",
"Only",
"those",
"instances",
"with",
"the",
"given",
"value",
"are",
"removed",
".",
"If",
"the",
"value",
"is",
"empty",
"all",
"tags",
"with",
"the",
"given",
"key",
"are",
"removed",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L73-L86 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.set_tag | def set_tag(self, p_key, p_value="", p_force_add=False, p_old_value=""):
"""
Sets a occurrence of the tag identified by p_key. Sets an arbitrary
instance of the tag when the todo contains multiple tags with this key.
When p_key does not exist, the tag is added.
When p_value is not set, the tag will be removed.
When p_force_add is true, a tag will always be added to the todo, in
case there is already a tag with the given key.
When p_old_value is set, all tags having this value will be set to the
new value.
"""
if p_value == "":
self.remove_tag(p_key, p_old_value)
return
tags = self.fields['tags']
value = p_old_value if p_old_value else self.tag_value(p_key)
if not p_force_add and value:
self._remove_tag_helper(p_key, value)
self.src = re.sub(
r'\b' + p_key + ':' + value + r'\b',
p_key + ':' + p_value,
self.src
)
else:
self.src += ' ' + p_key + ':' + p_value
try:
tags[p_key].append(p_value)
except KeyError:
tags[p_key] = [p_value] | python | def set_tag(self, p_key, p_value="", p_force_add=False, p_old_value=""):
"""
Sets a occurrence of the tag identified by p_key. Sets an arbitrary
instance of the tag when the todo contains multiple tags with this key.
When p_key does not exist, the tag is added.
When p_value is not set, the tag will be removed.
When p_force_add is true, a tag will always be added to the todo, in
case there is already a tag with the given key.
When p_old_value is set, all tags having this value will be set to the
new value.
"""
if p_value == "":
self.remove_tag(p_key, p_old_value)
return
tags = self.fields['tags']
value = p_old_value if p_old_value else self.tag_value(p_key)
if not p_force_add and value:
self._remove_tag_helper(p_key, value)
self.src = re.sub(
r'\b' + p_key + ':' + value + r'\b',
p_key + ':' + p_value,
self.src
)
else:
self.src += ' ' + p_key + ':' + p_value
try:
tags[p_key].append(p_value)
except KeyError:
tags[p_key] = [p_value] | [
"def",
"set_tag",
"(",
"self",
",",
"p_key",
",",
"p_value",
"=",
"\"\"",
",",
"p_force_add",
"=",
"False",
",",
"p_old_value",
"=",
"\"\"",
")",
":",
"if",
"p_value",
"==",
"\"\"",
":",
"self",
".",
"remove_tag",
"(",
"p_key",
",",
"p_old_value",
")",
"return",
"tags",
"=",
"self",
".",
"fields",
"[",
"'tags'",
"]",
"value",
"=",
"p_old_value",
"if",
"p_old_value",
"else",
"self",
".",
"tag_value",
"(",
"p_key",
")",
"if",
"not",
"p_force_add",
"and",
"value",
":",
"self",
".",
"_remove_tag_helper",
"(",
"p_key",
",",
"value",
")",
"self",
".",
"src",
"=",
"re",
".",
"sub",
"(",
"r'\\b'",
"+",
"p_key",
"+",
"':'",
"+",
"value",
"+",
"r'\\b'",
",",
"p_key",
"+",
"':'",
"+",
"p_value",
",",
"self",
".",
"src",
")",
"else",
":",
"self",
".",
"src",
"+=",
"' '",
"+",
"p_key",
"+",
"':'",
"+",
"p_value",
"try",
":",
"tags",
"[",
"p_key",
"]",
".",
"append",
"(",
"p_value",
")",
"except",
"KeyError",
":",
"tags",
"[",
"p_key",
"]",
"=",
"[",
"p_value",
"]"
] | Sets a occurrence of the tag identified by p_key. Sets an arbitrary
instance of the tag when the todo contains multiple tags with this key.
When p_key does not exist, the tag is added.
When p_value is not set, the tag will be removed.
When p_force_add is true, a tag will always be added to the todo, in
case there is already a tag with the given key.
When p_old_value is set, all tags having this value will be set to the
new value. | [
"Sets",
"a",
"occurrence",
"of",
"the",
"tag",
"identified",
"by",
"p_key",
".",
"Sets",
"an",
"arbitrary",
"instance",
"of",
"the",
"tag",
"when",
"the",
"todo",
"contains",
"multiple",
"tags",
"with",
"this",
"key",
".",
"When",
"p_key",
"does",
"not",
"exist",
"the",
"tag",
"is",
"added",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L88-L123 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.tags | def tags(self):
"""
Returns a list of tuples with key-value pairs representing tags in
this todo item.
"""
tags = self.fields['tags']
return [(t, v) for t in tags for v in tags[t]] | python | def tags(self):
"""
Returns a list of tuples with key-value pairs representing tags in
this todo item.
"""
tags = self.fields['tags']
return [(t, v) for t in tags for v in tags[t]] | [
"def",
"tags",
"(",
"self",
")",
":",
"tags",
"=",
"self",
".",
"fields",
"[",
"'tags'",
"]",
"return",
"[",
"(",
"t",
",",
"v",
")",
"for",
"t",
"in",
"tags",
"for",
"v",
"in",
"tags",
"[",
"t",
"]",
"]"
] | Returns a list of tuples with key-value pairs representing tags in
this todo item. | [
"Returns",
"a",
"list",
"of",
"tuples",
"with",
"key",
"-",
"value",
"pairs",
"representing",
"tags",
"in",
"this",
"todo",
"item",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L138-L144 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.set_source_text | def set_source_text(self, p_text):
""" Sets the todo source text. The text will be parsed again. """
self.src = p_text.strip()
self.fields = parse_line(self.src) | python | def set_source_text(self, p_text):
""" Sets the todo source text. The text will be parsed again. """
self.src = p_text.strip()
self.fields = parse_line(self.src) | [
"def",
"set_source_text",
"(",
"self",
",",
"p_text",
")",
":",
"self",
".",
"src",
"=",
"p_text",
".",
"strip",
"(",
")",
"self",
".",
"fields",
"=",
"parse_line",
"(",
"self",
".",
"src",
")"
] | Sets the todo source text. The text will be parsed again. | [
"Sets",
"the",
"todo",
"source",
"text",
".",
"The",
"text",
"will",
"be",
"parsed",
"again",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L177-L180 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.set_completed | def set_completed(self, p_completion_date=date.today()):
"""
Marks the todo as complete.
Sets the completed flag and sets the completion date to today.
"""
if not self.is_completed():
self.set_priority(None)
self.fields['completed'] = True
self.fields['completionDate'] = p_completion_date
self.src = re.sub(r'^(\([A-Z]\) )?',
'x ' + p_completion_date.isoformat() + ' ',
self.src) | python | def set_completed(self, p_completion_date=date.today()):
"""
Marks the todo as complete.
Sets the completed flag and sets the completion date to today.
"""
if not self.is_completed():
self.set_priority(None)
self.fields['completed'] = True
self.fields['completionDate'] = p_completion_date
self.src = re.sub(r'^(\([A-Z]\) )?',
'x ' + p_completion_date.isoformat() + ' ',
self.src) | [
"def",
"set_completed",
"(",
"self",
",",
"p_completion_date",
"=",
"date",
".",
"today",
"(",
")",
")",
":",
"if",
"not",
"self",
".",
"is_completed",
"(",
")",
":",
"self",
".",
"set_priority",
"(",
"None",
")",
"self",
".",
"fields",
"[",
"'completed'",
"]",
"=",
"True",
"self",
".",
"fields",
"[",
"'completionDate'",
"]",
"=",
"p_completion_date",
"self",
".",
"src",
"=",
"re",
".",
"sub",
"(",
"r'^(\\([A-Z]\\) )?'",
",",
"'x '",
"+",
"p_completion_date",
".",
"isoformat",
"(",
")",
"+",
"' '",
",",
"self",
".",
"src",
")"
] | Marks the todo as complete.
Sets the completed flag and sets the completion date to today. | [
"Marks",
"the",
"todo",
"as",
"complete",
".",
"Sets",
"the",
"completed",
"flag",
"and",
"sets",
"the",
"completion",
"date",
"to",
"today",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L201-L214 | train |
bram85/topydo | topydo/lib/TodoBase.py | TodoBase.set_creation_date | def set_creation_date(self, p_date=date.today()):
"""
Sets the creation date of a todo. Should be passed a date object.
"""
self.fields['creationDate'] = p_date
# not particularly pretty, but inspired by
# http://bugs.python.org/issue1519638 non-existent matches trigger
# exceptions, hence the lambda
self.src = re.sub(
r'^(x \d{4}-\d{2}-\d{2} |\([A-Z]\) )?(\d{4}-\d{2}-\d{2} )?(.*)$',
lambda m:
u"{}{} {}".format(m.group(1) or '', p_date.isoformat(),
m.group(3)), self.src) | python | def set_creation_date(self, p_date=date.today()):
"""
Sets the creation date of a todo. Should be passed a date object.
"""
self.fields['creationDate'] = p_date
# not particularly pretty, but inspired by
# http://bugs.python.org/issue1519638 non-existent matches trigger
# exceptions, hence the lambda
self.src = re.sub(
r'^(x \d{4}-\d{2}-\d{2} |\([A-Z]\) )?(\d{4}-\d{2}-\d{2} )?(.*)$',
lambda m:
u"{}{} {}".format(m.group(1) or '', p_date.isoformat(),
m.group(3)), self.src) | [
"def",
"set_creation_date",
"(",
"self",
",",
"p_date",
"=",
"date",
".",
"today",
"(",
")",
")",
":",
"self",
".",
"fields",
"[",
"'creationDate'",
"]",
"=",
"p_date",
"# not particularly pretty, but inspired by",
"# http://bugs.python.org/issue1519638 non-existent matches trigger",
"# exceptions, hence the lambda",
"self",
".",
"src",
"=",
"re",
".",
"sub",
"(",
"r'^(x \\d{4}-\\d{2}-\\d{2} |\\([A-Z]\\) )?(\\d{4}-\\d{2}-\\d{2} )?(.*)$'",
",",
"lambda",
"m",
":",
"u\"{}{} {}\"",
".",
"format",
"(",
"m",
".",
"group",
"(",
"1",
")",
"or",
"''",
",",
"p_date",
".",
"isoformat",
"(",
")",
",",
"m",
".",
"group",
"(",
"3",
")",
")",
",",
"self",
".",
"src",
")"
] | Sets the creation date of a todo. Should be passed a date object. | [
"Sets",
"the",
"creation",
"date",
"of",
"a",
"todo",
".",
"Should",
"be",
"passed",
"a",
"date",
"object",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoBase.py#L216-L229 | train |
bram85/topydo | topydo/ui/columns/TodoListWidget.py | TodoListWidget.update | def update(self):
"""
Updates the todo list according to the todos in the view associated
with this list.
"""
old_focus_position = self.todolist.focus
id_length = max_id_length(self.view.todolist.count())
del self.todolist[:]
for group, todos in self.view.groups.items():
if len(self.view.groups) > 1:
grouplabel = ", ".join(group)
self.todolist.append(urwid.Text(grouplabel))
self.todolist.append(urwid.Divider('-'))
for todo in todos:
todowidget = TodoWidget.create(todo, id_length)
todowidget.number = self.view.todolist.number(todo)
self.todolist.append(todowidget)
self.todolist.append(urwid.Divider('-'))
if old_focus_position:
try:
self.todolist.set_focus(old_focus_position)
except IndexError:
# scroll to the bottom if the last item disappeared from column
# -2 for the same reason as in self._scroll_to_bottom()
self.todolist.set_focus(len(self.todolist) - 2) | python | def update(self):
"""
Updates the todo list according to the todos in the view associated
with this list.
"""
old_focus_position = self.todolist.focus
id_length = max_id_length(self.view.todolist.count())
del self.todolist[:]
for group, todos in self.view.groups.items():
if len(self.view.groups) > 1:
grouplabel = ", ".join(group)
self.todolist.append(urwid.Text(grouplabel))
self.todolist.append(urwid.Divider('-'))
for todo in todos:
todowidget = TodoWidget.create(todo, id_length)
todowidget.number = self.view.todolist.number(todo)
self.todolist.append(todowidget)
self.todolist.append(urwid.Divider('-'))
if old_focus_position:
try:
self.todolist.set_focus(old_focus_position)
except IndexError:
# scroll to the bottom if the last item disappeared from column
# -2 for the same reason as in self._scroll_to_bottom()
self.todolist.set_focus(len(self.todolist) - 2) | [
"def",
"update",
"(",
"self",
")",
":",
"old_focus_position",
"=",
"self",
".",
"todolist",
".",
"focus",
"id_length",
"=",
"max_id_length",
"(",
"self",
".",
"view",
".",
"todolist",
".",
"count",
"(",
")",
")",
"del",
"self",
".",
"todolist",
"[",
":",
"]",
"for",
"group",
",",
"todos",
"in",
"self",
".",
"view",
".",
"groups",
".",
"items",
"(",
")",
":",
"if",
"len",
"(",
"self",
".",
"view",
".",
"groups",
")",
">",
"1",
":",
"grouplabel",
"=",
"\", \"",
".",
"join",
"(",
"group",
")",
"self",
".",
"todolist",
".",
"append",
"(",
"urwid",
".",
"Text",
"(",
"grouplabel",
")",
")",
"self",
".",
"todolist",
".",
"append",
"(",
"urwid",
".",
"Divider",
"(",
"'-'",
")",
")",
"for",
"todo",
"in",
"todos",
":",
"todowidget",
"=",
"TodoWidget",
".",
"create",
"(",
"todo",
",",
"id_length",
")",
"todowidget",
".",
"number",
"=",
"self",
".",
"view",
".",
"todolist",
".",
"number",
"(",
"todo",
")",
"self",
".",
"todolist",
".",
"append",
"(",
"todowidget",
")",
"self",
".",
"todolist",
".",
"append",
"(",
"urwid",
".",
"Divider",
"(",
"'-'",
")",
")",
"if",
"old_focus_position",
":",
"try",
":",
"self",
".",
"todolist",
".",
"set_focus",
"(",
"old_focus_position",
")",
"except",
"IndexError",
":",
"# scroll to the bottom if the last item disappeared from column",
"# -2 for the same reason as in self._scroll_to_bottom()",
"self",
".",
"todolist",
".",
"set_focus",
"(",
"len",
"(",
"self",
".",
"todolist",
")",
"-",
"2",
")"
] | Updates the todo list according to the todos in the view associated
with this list. | [
"Updates",
"the",
"todo",
"list",
"according",
"to",
"the",
"todos",
"in",
"the",
"view",
"associated",
"with",
"this",
"list",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/TodoListWidget.py#L87-L115 | train |
bram85/topydo | topydo/ui/columns/TodoListWidget.py | TodoListWidget._execute_on_selected | def _execute_on_selected(self, p_cmd_str, p_execute_signal):
"""
Executes command specified by p_cmd_str on selected todo item.
p_cmd_str should be a string with one replacement field ('{}') which
will be substituted by id of the selected todo item.
p_execute_signal is the signal name passed to the main loop. It should
be one of 'execute_command' or 'execute_command_silent'.
"""
try:
todo = self.listbox.focus.todo
todo_id = str(self.view.todolist.number(todo))
urwid.emit_signal(self, p_execute_signal, p_cmd_str, todo_id)
# force screen redraw after editing
if p_cmd_str.startswith('edit'):
urwid.emit_signal(self, 'refresh')
except AttributeError:
# No todo item selected
pass | python | def _execute_on_selected(self, p_cmd_str, p_execute_signal):
"""
Executes command specified by p_cmd_str on selected todo item.
p_cmd_str should be a string with one replacement field ('{}') which
will be substituted by id of the selected todo item.
p_execute_signal is the signal name passed to the main loop. It should
be one of 'execute_command' or 'execute_command_silent'.
"""
try:
todo = self.listbox.focus.todo
todo_id = str(self.view.todolist.number(todo))
urwid.emit_signal(self, p_execute_signal, p_cmd_str, todo_id)
# force screen redraw after editing
if p_cmd_str.startswith('edit'):
urwid.emit_signal(self, 'refresh')
except AttributeError:
# No todo item selected
pass | [
"def",
"_execute_on_selected",
"(",
"self",
",",
"p_cmd_str",
",",
"p_execute_signal",
")",
":",
"try",
":",
"todo",
"=",
"self",
".",
"listbox",
".",
"focus",
".",
"todo",
"todo_id",
"=",
"str",
"(",
"self",
".",
"view",
".",
"todolist",
".",
"number",
"(",
"todo",
")",
")",
"urwid",
".",
"emit_signal",
"(",
"self",
",",
"p_execute_signal",
",",
"p_cmd_str",
",",
"todo_id",
")",
"# force screen redraw after editing",
"if",
"p_cmd_str",
".",
"startswith",
"(",
"'edit'",
")",
":",
"urwid",
".",
"emit_signal",
"(",
"self",
",",
"'refresh'",
")",
"except",
"AttributeError",
":",
"# No todo item selected",
"pass"
] | Executes command specified by p_cmd_str on selected todo item.
p_cmd_str should be a string with one replacement field ('{}') which
will be substituted by id of the selected todo item.
p_execute_signal is the signal name passed to the main loop. It should
be one of 'execute_command' or 'execute_command_silent'. | [
"Executes",
"command",
"specified",
"by",
"p_cmd_str",
"on",
"selected",
"todo",
"item",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/TodoListWidget.py#L233-L254 | train |
bram85/topydo | topydo/ui/columns/TodoListWidget.py | TodoListWidget.execute_builtin_action | def execute_builtin_action(self, p_action_str, p_size=None):
"""
Executes built-in action specified in p_action_str.
Currently supported actions are: 'up', 'down', 'home', 'end',
'first_column', 'last_column', 'prev_column', 'next_column',
'append_column', 'insert_column', 'edit_column', 'delete_column',
'copy_column', swap_right', 'swap_left', 'postpone', 'postpone_s',
'pri', 'mark', 'mark_all, 'reset' and 'repeat'.
"""
column_actions = ['first_column',
'last_column',
'prev_column',
'next_column',
'append_column',
'insert_column',
'edit_column',
'delete_column',
'copy_column',
'swap_left',
'swap_right',
'reset',
]
if p_action_str in column_actions:
urwid.emit_signal(self, 'column_action', p_action_str)
elif p_action_str in ['up', 'down']:
self.listbox.keypress(p_size, p_action_str)
elif p_action_str == 'home':
self._scroll_to_top(p_size)
elif p_action_str == 'end':
self._scroll_to_bottom(p_size)
elif p_action_str in ['postpone', 'postpone_s']:
pass
elif p_action_str == 'pri':
pass
elif p_action_str == 'mark':
self._toggle_marked_status()
elif p_action_str == 'mark_all':
self._mark_all()
elif p_action_str == 'repeat':
self._repeat_cmd() | python | def execute_builtin_action(self, p_action_str, p_size=None):
"""
Executes built-in action specified in p_action_str.
Currently supported actions are: 'up', 'down', 'home', 'end',
'first_column', 'last_column', 'prev_column', 'next_column',
'append_column', 'insert_column', 'edit_column', 'delete_column',
'copy_column', swap_right', 'swap_left', 'postpone', 'postpone_s',
'pri', 'mark', 'mark_all, 'reset' and 'repeat'.
"""
column_actions = ['first_column',
'last_column',
'prev_column',
'next_column',
'append_column',
'insert_column',
'edit_column',
'delete_column',
'copy_column',
'swap_left',
'swap_right',
'reset',
]
if p_action_str in column_actions:
urwid.emit_signal(self, 'column_action', p_action_str)
elif p_action_str in ['up', 'down']:
self.listbox.keypress(p_size, p_action_str)
elif p_action_str == 'home':
self._scroll_to_top(p_size)
elif p_action_str == 'end':
self._scroll_to_bottom(p_size)
elif p_action_str in ['postpone', 'postpone_s']:
pass
elif p_action_str == 'pri':
pass
elif p_action_str == 'mark':
self._toggle_marked_status()
elif p_action_str == 'mark_all':
self._mark_all()
elif p_action_str == 'repeat':
self._repeat_cmd() | [
"def",
"execute_builtin_action",
"(",
"self",
",",
"p_action_str",
",",
"p_size",
"=",
"None",
")",
":",
"column_actions",
"=",
"[",
"'first_column'",
",",
"'last_column'",
",",
"'prev_column'",
",",
"'next_column'",
",",
"'append_column'",
",",
"'insert_column'",
",",
"'edit_column'",
",",
"'delete_column'",
",",
"'copy_column'",
",",
"'swap_left'",
",",
"'swap_right'",
",",
"'reset'",
",",
"]",
"if",
"p_action_str",
"in",
"column_actions",
":",
"urwid",
".",
"emit_signal",
"(",
"self",
",",
"'column_action'",
",",
"p_action_str",
")",
"elif",
"p_action_str",
"in",
"[",
"'up'",
",",
"'down'",
"]",
":",
"self",
".",
"listbox",
".",
"keypress",
"(",
"p_size",
",",
"p_action_str",
")",
"elif",
"p_action_str",
"==",
"'home'",
":",
"self",
".",
"_scroll_to_top",
"(",
"p_size",
")",
"elif",
"p_action_str",
"==",
"'end'",
":",
"self",
".",
"_scroll_to_bottom",
"(",
"p_size",
")",
"elif",
"p_action_str",
"in",
"[",
"'postpone'",
",",
"'postpone_s'",
"]",
":",
"pass",
"elif",
"p_action_str",
"==",
"'pri'",
":",
"pass",
"elif",
"p_action_str",
"==",
"'mark'",
":",
"self",
".",
"_toggle_marked_status",
"(",
")",
"elif",
"p_action_str",
"==",
"'mark_all'",
":",
"self",
".",
"_mark_all",
"(",
")",
"elif",
"p_action_str",
"==",
"'repeat'",
":",
"self",
".",
"_repeat_cmd",
"(",
")"
] | Executes built-in action specified in p_action_str.
Currently supported actions are: 'up', 'down', 'home', 'end',
'first_column', 'last_column', 'prev_column', 'next_column',
'append_column', 'insert_column', 'edit_column', 'delete_column',
'copy_column', swap_right', 'swap_left', 'postpone', 'postpone_s',
'pri', 'mark', 'mark_all, 'reset' and 'repeat'. | [
"Executes",
"built",
"-",
"in",
"action",
"specified",
"in",
"p_action_str",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/TodoListWidget.py#L277-L318 | train |
bram85/topydo | topydo/ui/columns/TodoListWidget.py | TodoListWidget._add_pending_action | def _add_pending_action(self, p_action, p_size):
"""
Creates action waiting for execution and forwards it to the mainloop.
"""
def generate_callback():
def callback(*args):
self.resolve_action(p_action, p_size)
self.keystate = None
return callback
urwid.emit_signal(self, 'add_pending_action', generate_callback()) | python | def _add_pending_action(self, p_action, p_size):
"""
Creates action waiting for execution and forwards it to the mainloop.
"""
def generate_callback():
def callback(*args):
self.resolve_action(p_action, p_size)
self.keystate = None
return callback
urwid.emit_signal(self, 'add_pending_action', generate_callback()) | [
"def",
"_add_pending_action",
"(",
"self",
",",
"p_action",
",",
"p_size",
")",
":",
"def",
"generate_callback",
"(",
")",
":",
"def",
"callback",
"(",
"*",
"args",
")",
":",
"self",
".",
"resolve_action",
"(",
"p_action",
",",
"p_size",
")",
"self",
".",
"keystate",
"=",
"None",
"return",
"callback",
"urwid",
".",
"emit_signal",
"(",
"self",
",",
"'add_pending_action'",
",",
"generate_callback",
"(",
")",
")"
] | Creates action waiting for execution and forwards it to the mainloop. | [
"Creates",
"action",
"waiting",
"for",
"execution",
"and",
"forwards",
"it",
"to",
"the",
"mainloop",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/columns/TodoListWidget.py#L320-L331 | train |
bram85/topydo | topydo/lib/TodoFile.py | TodoFile.read | def read(self):
""" Reads the todo.txt file and returns a list of todo items. """
todos = []
try:
todofile = codecs.open(self.path, 'r', encoding="utf-8")
todos = todofile.readlines()
todofile.close()
except IOError:
pass
return todos | python | def read(self):
""" Reads the todo.txt file and returns a list of todo items. """
todos = []
try:
todofile = codecs.open(self.path, 'r', encoding="utf-8")
todos = todofile.readlines()
todofile.close()
except IOError:
pass
return todos | [
"def",
"read",
"(",
"self",
")",
":",
"todos",
"=",
"[",
"]",
"try",
":",
"todofile",
"=",
"codecs",
".",
"open",
"(",
"self",
".",
"path",
",",
"'r'",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"todos",
"=",
"todofile",
".",
"readlines",
"(",
")",
"todofile",
".",
"close",
"(",
")",
"except",
"IOError",
":",
"pass",
"return",
"todos"
] | Reads the todo.txt file and returns a list of todo items. | [
"Reads",
"the",
"todo",
".",
"txt",
"file",
"and",
"returns",
"a",
"list",
"of",
"todo",
"items",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoFile.py#L34-L44 | train |
bram85/topydo | topydo/lib/TodoFile.py | TodoFile.write | def write(self, p_todos):
"""
Writes all the todo items to the todo.txt file.
p_todos can be a list of todo items, or a string that is just written
to the file.
"""
todofile = codecs.open(self.path, 'w', encoding="utf-8")
if p_todos is list:
for todo in p_todos:
todofile.write(str(todo))
else:
todofile.write(p_todos)
todofile.write("\n")
todofile.close() | python | def write(self, p_todos):
"""
Writes all the todo items to the todo.txt file.
p_todos can be a list of todo items, or a string that is just written
to the file.
"""
todofile = codecs.open(self.path, 'w', encoding="utf-8")
if p_todos is list:
for todo in p_todos:
todofile.write(str(todo))
else:
todofile.write(p_todos)
todofile.write("\n")
todofile.close() | [
"def",
"write",
"(",
"self",
",",
"p_todos",
")",
":",
"todofile",
"=",
"codecs",
".",
"open",
"(",
"self",
".",
"path",
",",
"'w'",
",",
"encoding",
"=",
"\"utf-8\"",
")",
"if",
"p_todos",
"is",
"list",
":",
"for",
"todo",
"in",
"p_todos",
":",
"todofile",
".",
"write",
"(",
"str",
"(",
"todo",
")",
")",
"else",
":",
"todofile",
".",
"write",
"(",
"p_todos",
")",
"todofile",
".",
"write",
"(",
"\"\\n\"",
")",
"todofile",
".",
"close",
"(",
")"
] | Writes all the todo items to the todo.txt file.
p_todos can be a list of todo items, or a string that is just written
to the file. | [
"Writes",
"all",
"the",
"todo",
"items",
"to",
"the",
"todo",
".",
"txt",
"file",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoFile.py#L46-L64 | train |
bram85/topydo | topydo/ui/UILoader.py | main | def main():
""" Main entry point of the CLI. """
try:
args = sys.argv[1:]
try:
_, args = getopt.getopt(args, MAIN_OPTS, MAIN_LONG_OPTS)
except getopt.GetoptError as e:
error(str(e))
sys.exit(1)
if args[0] == 'prompt':
try:
from topydo.ui.prompt.Prompt import PromptApplication
PromptApplication().run()
except ImportError:
error("Some additional dependencies for prompt mode were not installed, please install with 'pip3 install topydo[prompt]'")
elif args[0] == 'columns':
try:
from topydo.ui.columns.Main import UIApplication
UIApplication().run()
except ImportError:
error("Some additional dependencies for column mode were not installed, please install with 'pip3 install topydo[columns]'")
except NameError as err:
if _WINDOWS:
error("Column mode is not supported on Windows.")
else:
error("Could not load column mode: {}".format(err))
else:
CLIApplication().run()
except IndexError:
CLIApplication().run() | python | def main():
""" Main entry point of the CLI. """
try:
args = sys.argv[1:]
try:
_, args = getopt.getopt(args, MAIN_OPTS, MAIN_LONG_OPTS)
except getopt.GetoptError as e:
error(str(e))
sys.exit(1)
if args[0] == 'prompt':
try:
from topydo.ui.prompt.Prompt import PromptApplication
PromptApplication().run()
except ImportError:
error("Some additional dependencies for prompt mode were not installed, please install with 'pip3 install topydo[prompt]'")
elif args[0] == 'columns':
try:
from topydo.ui.columns.Main import UIApplication
UIApplication().run()
except ImportError:
error("Some additional dependencies for column mode were not installed, please install with 'pip3 install topydo[columns]'")
except NameError as err:
if _WINDOWS:
error("Column mode is not supported on Windows.")
else:
error("Could not load column mode: {}".format(err))
else:
CLIApplication().run()
except IndexError:
CLIApplication().run() | [
"def",
"main",
"(",
")",
":",
"try",
":",
"args",
"=",
"sys",
".",
"argv",
"[",
"1",
":",
"]",
"try",
":",
"_",
",",
"args",
"=",
"getopt",
".",
"getopt",
"(",
"args",
",",
"MAIN_OPTS",
",",
"MAIN_LONG_OPTS",
")",
"except",
"getopt",
".",
"GetoptError",
"as",
"e",
":",
"error",
"(",
"str",
"(",
"e",
")",
")",
"sys",
".",
"exit",
"(",
"1",
")",
"if",
"args",
"[",
"0",
"]",
"==",
"'prompt'",
":",
"try",
":",
"from",
"topydo",
".",
"ui",
".",
"prompt",
".",
"Prompt",
"import",
"PromptApplication",
"PromptApplication",
"(",
")",
".",
"run",
"(",
")",
"except",
"ImportError",
":",
"error",
"(",
"\"Some additional dependencies for prompt mode were not installed, please install with 'pip3 install topydo[prompt]'\"",
")",
"elif",
"args",
"[",
"0",
"]",
"==",
"'columns'",
":",
"try",
":",
"from",
"topydo",
".",
"ui",
".",
"columns",
".",
"Main",
"import",
"UIApplication",
"UIApplication",
"(",
")",
".",
"run",
"(",
")",
"except",
"ImportError",
":",
"error",
"(",
"\"Some additional dependencies for column mode were not installed, please install with 'pip3 install topydo[columns]'\"",
")",
"except",
"NameError",
"as",
"err",
":",
"if",
"_WINDOWS",
":",
"error",
"(",
"\"Column mode is not supported on Windows.\"",
")",
"else",
":",
"error",
"(",
"\"Could not load column mode: {}\"",
".",
"format",
"(",
"err",
")",
")",
"else",
":",
"CLIApplication",
"(",
")",
".",
"run",
"(",
")",
"except",
"IndexError",
":",
"CLIApplication",
"(",
")",
".",
"run",
"(",
")"
] | Main entry point of the CLI. | [
"Main",
"entry",
"point",
"of",
"the",
"CLI",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/UILoader.py#L33-L64 | train |
bram85/topydo | topydo/lib/Importance.py | importance | def importance(p_todo, p_ignore_weekend=config().ignore_weekends()):
"""
Calculates the importance of the given task.
Returns an importance of zero when the task has been completed.
If p_ignore_weekend is True, the importance value of the due date will be
calculated as if Friday is immediately followed by Monday. This in case of
a todo list at the office and you don't work during the weekends (you
don't, right?)
"""
result = 2
priority = p_todo.priority()
result += IMPORTANCE_VALUE[priority] if priority in IMPORTANCE_VALUE else 0
if p_todo.has_tag(config().tag_due()):
days_left = p_todo.days_till_due()
if days_left >= 7 and days_left < 14:
result += 1
elif days_left >= 2 and days_left < 7:
result += 2
elif days_left >= 1 and days_left < 2:
result += 3
elif days_left >= 0 and days_left < 1:
result += 5
elif days_left < 0:
result += 6
if p_ignore_weekend and is_due_next_monday(p_todo):
result += 1
if p_todo.has_tag(config().tag_star()):
result += 1
return result if not p_todo.is_completed() else 0 | python | def importance(p_todo, p_ignore_weekend=config().ignore_weekends()):
"""
Calculates the importance of the given task.
Returns an importance of zero when the task has been completed.
If p_ignore_weekend is True, the importance value of the due date will be
calculated as if Friday is immediately followed by Monday. This in case of
a todo list at the office and you don't work during the weekends (you
don't, right?)
"""
result = 2
priority = p_todo.priority()
result += IMPORTANCE_VALUE[priority] if priority in IMPORTANCE_VALUE else 0
if p_todo.has_tag(config().tag_due()):
days_left = p_todo.days_till_due()
if days_left >= 7 and days_left < 14:
result += 1
elif days_left >= 2 and days_left < 7:
result += 2
elif days_left >= 1 and days_left < 2:
result += 3
elif days_left >= 0 and days_left < 1:
result += 5
elif days_left < 0:
result += 6
if p_ignore_weekend and is_due_next_monday(p_todo):
result += 1
if p_todo.has_tag(config().tag_star()):
result += 1
return result if not p_todo.is_completed() else 0 | [
"def",
"importance",
"(",
"p_todo",
",",
"p_ignore_weekend",
"=",
"config",
"(",
")",
".",
"ignore_weekends",
"(",
")",
")",
":",
"result",
"=",
"2",
"priority",
"=",
"p_todo",
".",
"priority",
"(",
")",
"result",
"+=",
"IMPORTANCE_VALUE",
"[",
"priority",
"]",
"if",
"priority",
"in",
"IMPORTANCE_VALUE",
"else",
"0",
"if",
"p_todo",
".",
"has_tag",
"(",
"config",
"(",
")",
".",
"tag_due",
"(",
")",
")",
":",
"days_left",
"=",
"p_todo",
".",
"days_till_due",
"(",
")",
"if",
"days_left",
">=",
"7",
"and",
"days_left",
"<",
"14",
":",
"result",
"+=",
"1",
"elif",
"days_left",
">=",
"2",
"and",
"days_left",
"<",
"7",
":",
"result",
"+=",
"2",
"elif",
"days_left",
">=",
"1",
"and",
"days_left",
"<",
"2",
":",
"result",
"+=",
"3",
"elif",
"days_left",
">=",
"0",
"and",
"days_left",
"<",
"1",
":",
"result",
"+=",
"5",
"elif",
"days_left",
"<",
"0",
":",
"result",
"+=",
"6",
"if",
"p_ignore_weekend",
"and",
"is_due_next_monday",
"(",
"p_todo",
")",
":",
"result",
"+=",
"1",
"if",
"p_todo",
".",
"has_tag",
"(",
"config",
"(",
")",
".",
"tag_star",
"(",
")",
")",
":",
"result",
"+=",
"1",
"return",
"result",
"if",
"not",
"p_todo",
".",
"is_completed",
"(",
")",
"else",
"0"
] | Calculates the importance of the given task.
Returns an importance of zero when the task has been completed.
If p_ignore_weekend is True, the importance value of the due date will be
calculated as if Friday is immediately followed by Monday. This in case of
a todo list at the office and you don't work during the weekends (you
don't, right?) | [
"Calculates",
"the",
"importance",
"of",
"the",
"given",
"task",
".",
"Returns",
"an",
"importance",
"of",
"zero",
"when",
"the",
"task",
"has",
"been",
"completed",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Importance.py#L44-L79 | train |
bram85/topydo | topydo/lib/TodoList.py | TodoList._maintain_dep_graph | def _maintain_dep_graph(self, p_todo):
"""
Makes sure that the dependency graph is consistent according to the
given todo.
"""
dep_id = p_todo.tag_value('id')
# maintain dependency graph
if dep_id:
self._parentdict[dep_id] = p_todo
self._depgraph.add_node(hash(p_todo))
# connect all tasks we have in memory so far that refer to this
# task
for dep in \
[dep for dep in self._todos if dep.has_tag('p', dep_id)]:
self._add_edge(p_todo, dep, dep_id)
for dep_id in p_todo.tag_values('p'):
try:
parent = self._parentdict[dep_id]
self._add_edge(parent, p_todo, dep_id)
except KeyError:
pass | python | def _maintain_dep_graph(self, p_todo):
"""
Makes sure that the dependency graph is consistent according to the
given todo.
"""
dep_id = p_todo.tag_value('id')
# maintain dependency graph
if dep_id:
self._parentdict[dep_id] = p_todo
self._depgraph.add_node(hash(p_todo))
# connect all tasks we have in memory so far that refer to this
# task
for dep in \
[dep for dep in self._todos if dep.has_tag('p', dep_id)]:
self._add_edge(p_todo, dep, dep_id)
for dep_id in p_todo.tag_values('p'):
try:
parent = self._parentdict[dep_id]
self._add_edge(parent, p_todo, dep_id)
except KeyError:
pass | [
"def",
"_maintain_dep_graph",
"(",
"self",
",",
"p_todo",
")",
":",
"dep_id",
"=",
"p_todo",
".",
"tag_value",
"(",
"'id'",
")",
"# maintain dependency graph",
"if",
"dep_id",
":",
"self",
".",
"_parentdict",
"[",
"dep_id",
"]",
"=",
"p_todo",
"self",
".",
"_depgraph",
".",
"add_node",
"(",
"hash",
"(",
"p_todo",
")",
")",
"# connect all tasks we have in memory so far that refer to this",
"# task",
"for",
"dep",
"in",
"[",
"dep",
"for",
"dep",
"in",
"self",
".",
"_todos",
"if",
"dep",
".",
"has_tag",
"(",
"'p'",
",",
"dep_id",
")",
"]",
":",
"self",
".",
"_add_edge",
"(",
"p_todo",
",",
"dep",
",",
"dep_id",
")",
"for",
"dep_id",
"in",
"p_todo",
".",
"tag_values",
"(",
"'p'",
")",
":",
"try",
":",
"parent",
"=",
"self",
".",
"_parentdict",
"[",
"dep_id",
"]",
"self",
".",
"_add_edge",
"(",
"parent",
",",
"p_todo",
",",
"dep_id",
")",
"except",
"KeyError",
":",
"pass"
] | Makes sure that the dependency graph is consistent according to the
given todo. | [
"Makes",
"sure",
"that",
"the",
"dependency",
"graph",
"is",
"consistent",
"according",
"to",
"the",
"given",
"todo",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoList.py#L86-L109 | train |
bram85/topydo | topydo/lib/TodoList.py | TodoList.add_dependency | def add_dependency(self, p_from_todo, p_to_todo):
""" Adds a dependency from task 1 to task 2. """
def find_next_id():
"""
Find a new unused ID.
Unused means that no task has it as an 'id' value or as a 'p'
value.
"""
def id_exists(p_id):
"""
Returns True if there exists a todo with the given parent ID.
"""
for todo in self._todos:
number = str(p_id)
if todo.has_tag('id', number) or todo.has_tag('p', number):
return True
return False
new_id = 1
while id_exists(new_id):
new_id += 1
return str(new_id)
def append_projects_to_subtodo():
"""
Appends projects in the parent todo item that are not present in
the sub todo item.
"""
if config().append_parent_projects():
for project in p_from_todo.projects() - p_to_todo.projects():
self.append(p_to_todo, "+{}".format(project))
def append_contexts_to_subtodo():
"""
Appends contexts in the parent todo item that are not present in
the sub todo item.
"""
if config().append_parent_contexts():
for context in p_from_todo.contexts() - p_to_todo.contexts():
self.append(p_to_todo, "@{}".format(context))
if p_from_todo != p_to_todo and not self._depgraph.has_edge(
hash(p_from_todo), hash(p_to_todo)):
dep_id = None
if p_from_todo.has_tag('id'):
dep_id = p_from_todo.tag_value('id')
else:
dep_id = find_next_id()
p_from_todo.set_tag('id', dep_id)
p_to_todo.add_tag('p', dep_id)
self._add_edge(p_from_todo, p_to_todo, dep_id)
append_projects_to_subtodo()
append_contexts_to_subtodo()
self.dirty = True | python | def add_dependency(self, p_from_todo, p_to_todo):
""" Adds a dependency from task 1 to task 2. """
def find_next_id():
"""
Find a new unused ID.
Unused means that no task has it as an 'id' value or as a 'p'
value.
"""
def id_exists(p_id):
"""
Returns True if there exists a todo with the given parent ID.
"""
for todo in self._todos:
number = str(p_id)
if todo.has_tag('id', number) or todo.has_tag('p', number):
return True
return False
new_id = 1
while id_exists(new_id):
new_id += 1
return str(new_id)
def append_projects_to_subtodo():
"""
Appends projects in the parent todo item that are not present in
the sub todo item.
"""
if config().append_parent_projects():
for project in p_from_todo.projects() - p_to_todo.projects():
self.append(p_to_todo, "+{}".format(project))
def append_contexts_to_subtodo():
"""
Appends contexts in the parent todo item that are not present in
the sub todo item.
"""
if config().append_parent_contexts():
for context in p_from_todo.contexts() - p_to_todo.contexts():
self.append(p_to_todo, "@{}".format(context))
if p_from_todo != p_to_todo and not self._depgraph.has_edge(
hash(p_from_todo), hash(p_to_todo)):
dep_id = None
if p_from_todo.has_tag('id'):
dep_id = p_from_todo.tag_value('id')
else:
dep_id = find_next_id()
p_from_todo.set_tag('id', dep_id)
p_to_todo.add_tag('p', dep_id)
self._add_edge(p_from_todo, p_to_todo, dep_id)
append_projects_to_subtodo()
append_contexts_to_subtodo()
self.dirty = True | [
"def",
"add_dependency",
"(",
"self",
",",
"p_from_todo",
",",
"p_to_todo",
")",
":",
"def",
"find_next_id",
"(",
")",
":",
"\"\"\"\n Find a new unused ID.\n Unused means that no task has it as an 'id' value or as a 'p'\n value.\n \"\"\"",
"def",
"id_exists",
"(",
"p_id",
")",
":",
"\"\"\"\n Returns True if there exists a todo with the given parent ID.\n \"\"\"",
"for",
"todo",
"in",
"self",
".",
"_todos",
":",
"number",
"=",
"str",
"(",
"p_id",
")",
"if",
"todo",
".",
"has_tag",
"(",
"'id'",
",",
"number",
")",
"or",
"todo",
".",
"has_tag",
"(",
"'p'",
",",
"number",
")",
":",
"return",
"True",
"return",
"False",
"new_id",
"=",
"1",
"while",
"id_exists",
"(",
"new_id",
")",
":",
"new_id",
"+=",
"1",
"return",
"str",
"(",
"new_id",
")",
"def",
"append_projects_to_subtodo",
"(",
")",
":",
"\"\"\"\n Appends projects in the parent todo item that are not present in\n the sub todo item.\n \"\"\"",
"if",
"config",
"(",
")",
".",
"append_parent_projects",
"(",
")",
":",
"for",
"project",
"in",
"p_from_todo",
".",
"projects",
"(",
")",
"-",
"p_to_todo",
".",
"projects",
"(",
")",
":",
"self",
".",
"append",
"(",
"p_to_todo",
",",
"\"+{}\"",
".",
"format",
"(",
"project",
")",
")",
"def",
"append_contexts_to_subtodo",
"(",
")",
":",
"\"\"\"\n Appends contexts in the parent todo item that are not present in\n the sub todo item.\n \"\"\"",
"if",
"config",
"(",
")",
".",
"append_parent_contexts",
"(",
")",
":",
"for",
"context",
"in",
"p_from_todo",
".",
"contexts",
"(",
")",
"-",
"p_to_todo",
".",
"contexts",
"(",
")",
":",
"self",
".",
"append",
"(",
"p_to_todo",
",",
"\"@{}\"",
".",
"format",
"(",
"context",
")",
")",
"if",
"p_from_todo",
"!=",
"p_to_todo",
"and",
"not",
"self",
".",
"_depgraph",
".",
"has_edge",
"(",
"hash",
"(",
"p_from_todo",
")",
",",
"hash",
"(",
"p_to_todo",
")",
")",
":",
"dep_id",
"=",
"None",
"if",
"p_from_todo",
".",
"has_tag",
"(",
"'id'",
")",
":",
"dep_id",
"=",
"p_from_todo",
".",
"tag_value",
"(",
"'id'",
")",
"else",
":",
"dep_id",
"=",
"find_next_id",
"(",
")",
"p_from_todo",
".",
"set_tag",
"(",
"'id'",
",",
"dep_id",
")",
"p_to_todo",
".",
"add_tag",
"(",
"'p'",
",",
"dep_id",
")",
"self",
".",
"_add_edge",
"(",
"p_from_todo",
",",
"p_to_todo",
",",
"dep_id",
")",
"append_projects_to_subtodo",
"(",
")",
"append_contexts_to_subtodo",
"(",
")",
"self",
".",
"dirty",
"=",
"True"
] | Adds a dependency from task 1 to task 2. | [
"Adds",
"a",
"dependency",
"from",
"task",
"1",
"to",
"task",
"2",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoList.py#L153-L210 | train |
bram85/topydo | topydo/lib/TodoList.py | TodoList.remove_dependency | def remove_dependency(self, p_from_todo, p_to_todo, p_leave_tags=False):
""" Removes a dependency between two todos. """
dep_id = p_from_todo.tag_value('id')
if dep_id:
self._depgraph.remove_edge(hash(p_from_todo), hash(p_to_todo))
self.dirty = True
# clean dangling dependency tags
if dep_id and not p_leave_tags:
p_to_todo.remove_tag('p', dep_id)
if not self.children(p_from_todo, True):
p_from_todo.remove_tag('id')
del self._parentdict[dep_id] | python | def remove_dependency(self, p_from_todo, p_to_todo, p_leave_tags=False):
""" Removes a dependency between two todos. """
dep_id = p_from_todo.tag_value('id')
if dep_id:
self._depgraph.remove_edge(hash(p_from_todo), hash(p_to_todo))
self.dirty = True
# clean dangling dependency tags
if dep_id and not p_leave_tags:
p_to_todo.remove_tag('p', dep_id)
if not self.children(p_from_todo, True):
p_from_todo.remove_tag('id')
del self._parentdict[dep_id] | [
"def",
"remove_dependency",
"(",
"self",
",",
"p_from_todo",
",",
"p_to_todo",
",",
"p_leave_tags",
"=",
"False",
")",
":",
"dep_id",
"=",
"p_from_todo",
".",
"tag_value",
"(",
"'id'",
")",
"if",
"dep_id",
":",
"self",
".",
"_depgraph",
".",
"remove_edge",
"(",
"hash",
"(",
"p_from_todo",
")",
",",
"hash",
"(",
"p_to_todo",
")",
")",
"self",
".",
"dirty",
"=",
"True",
"# clean dangling dependency tags",
"if",
"dep_id",
"and",
"not",
"p_leave_tags",
":",
"p_to_todo",
".",
"remove_tag",
"(",
"'p'",
",",
"dep_id",
")",
"if",
"not",
"self",
".",
"children",
"(",
"p_from_todo",
",",
"True",
")",
":",
"p_from_todo",
".",
"remove_tag",
"(",
"'id'",
")",
"del",
"self",
".",
"_parentdict",
"[",
"dep_id",
"]"
] | Removes a dependency between two todos. | [
"Removes",
"a",
"dependency",
"between",
"two",
"todos",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoList.py#L213-L227 | train |
bram85/topydo | topydo/lib/TodoList.py | TodoList.clean_dependencies | def clean_dependencies(self):
"""
Cleans the dependency graph.
This is achieved by performing a transitive reduction on the dependency
graph and removing unused dependency ids from the graph (in that
order).
"""
def remove_tag(p_todo, p_tag, p_value):
"""
Removes a tag from a todo item.
"""
p_todo.remove_tag(p_tag, p_value)
self.dirty = True
def clean_parent_relations():
"""
Remove id: tags for todos without child todo items.
"""
for todo in [todo for todo in self._todos if todo.has_tag('id')]:
value = todo.tag_value('id')
if not self._depgraph.has_edge_id(value):
remove_tag(todo, 'id', value)
del self._parentdict[value]
def clean_orphan_relations():
"""
Remove p: tags for todos referring to a parent that is not in the
dependency graph anymore.
"""
for todo in [todo for todo in self._todos if todo.has_tag('p')]:
for value in todo.tag_values('p'):
parent = self.todo_by_dep_id(value)
if not self._depgraph.has_edge(hash(parent), hash(todo)):
remove_tag(todo, 'p', value)
self._depgraph.transitively_reduce()
clean_parent_relations()
clean_orphan_relations() | python | def clean_dependencies(self):
"""
Cleans the dependency graph.
This is achieved by performing a transitive reduction on the dependency
graph and removing unused dependency ids from the graph (in that
order).
"""
def remove_tag(p_todo, p_tag, p_value):
"""
Removes a tag from a todo item.
"""
p_todo.remove_tag(p_tag, p_value)
self.dirty = True
def clean_parent_relations():
"""
Remove id: tags for todos without child todo items.
"""
for todo in [todo for todo in self._todos if todo.has_tag('id')]:
value = todo.tag_value('id')
if not self._depgraph.has_edge_id(value):
remove_tag(todo, 'id', value)
del self._parentdict[value]
def clean_orphan_relations():
"""
Remove p: tags for todos referring to a parent that is not in the
dependency graph anymore.
"""
for todo in [todo for todo in self._todos if todo.has_tag('p')]:
for value in todo.tag_values('p'):
parent = self.todo_by_dep_id(value)
if not self._depgraph.has_edge(hash(parent), hash(todo)):
remove_tag(todo, 'p', value)
self._depgraph.transitively_reduce()
clean_parent_relations()
clean_orphan_relations() | [
"def",
"clean_dependencies",
"(",
"self",
")",
":",
"def",
"remove_tag",
"(",
"p_todo",
",",
"p_tag",
",",
"p_value",
")",
":",
"\"\"\"\n Removes a tag from a todo item.\n \"\"\"",
"p_todo",
".",
"remove_tag",
"(",
"p_tag",
",",
"p_value",
")",
"self",
".",
"dirty",
"=",
"True",
"def",
"clean_parent_relations",
"(",
")",
":",
"\"\"\"\n Remove id: tags for todos without child todo items.\n \"\"\"",
"for",
"todo",
"in",
"[",
"todo",
"for",
"todo",
"in",
"self",
".",
"_todos",
"if",
"todo",
".",
"has_tag",
"(",
"'id'",
")",
"]",
":",
"value",
"=",
"todo",
".",
"tag_value",
"(",
"'id'",
")",
"if",
"not",
"self",
".",
"_depgraph",
".",
"has_edge_id",
"(",
"value",
")",
":",
"remove_tag",
"(",
"todo",
",",
"'id'",
",",
"value",
")",
"del",
"self",
".",
"_parentdict",
"[",
"value",
"]",
"def",
"clean_orphan_relations",
"(",
")",
":",
"\"\"\"\n Remove p: tags for todos referring to a parent that is not in the\n dependency graph anymore.\n \"\"\"",
"for",
"todo",
"in",
"[",
"todo",
"for",
"todo",
"in",
"self",
".",
"_todos",
"if",
"todo",
".",
"has_tag",
"(",
"'p'",
")",
"]",
":",
"for",
"value",
"in",
"todo",
".",
"tag_values",
"(",
"'p'",
")",
":",
"parent",
"=",
"self",
".",
"todo_by_dep_id",
"(",
"value",
")",
"if",
"not",
"self",
".",
"_depgraph",
".",
"has_edge",
"(",
"hash",
"(",
"parent",
")",
",",
"hash",
"(",
"todo",
")",
")",
":",
"remove_tag",
"(",
"todo",
",",
"'p'",
",",
"value",
")",
"self",
".",
"_depgraph",
".",
"transitively_reduce",
"(",
")",
"clean_parent_relations",
"(",
")",
"clean_orphan_relations",
"(",
")"
] | Cleans the dependency graph.
This is achieved by performing a transitive reduction on the dependency
graph and removing unused dependency ids from the graph (in that
order). | [
"Cleans",
"the",
"dependency",
"graph",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/TodoList.py#L250-L291 | train |
bram85/topydo | topydo/lib/printers/Json.py | _convert_todo | def _convert_todo(p_todo):
""" Converts a Todo instance to a dictionary. """
creation_date = p_todo.creation_date()
completion_date = p_todo.completion_date()
result = {
'source': p_todo.source(),
'text': p_todo.text(),
'priority': p_todo.priority(),
'completed': p_todo.is_completed(),
'tags': p_todo.tags(),
'projects': list(p_todo.projects()),
'contexts': list(p_todo.contexts()),
'creation_date':
creation_date.isoformat() if creation_date else None,
'completion_date':
completion_date.isoformat() if completion_date else None
}
return result | python | def _convert_todo(p_todo):
""" Converts a Todo instance to a dictionary. """
creation_date = p_todo.creation_date()
completion_date = p_todo.completion_date()
result = {
'source': p_todo.source(),
'text': p_todo.text(),
'priority': p_todo.priority(),
'completed': p_todo.is_completed(),
'tags': p_todo.tags(),
'projects': list(p_todo.projects()),
'contexts': list(p_todo.contexts()),
'creation_date':
creation_date.isoformat() if creation_date else None,
'completion_date':
completion_date.isoformat() if completion_date else None
}
return result | [
"def",
"_convert_todo",
"(",
"p_todo",
")",
":",
"creation_date",
"=",
"p_todo",
".",
"creation_date",
"(",
")",
"completion_date",
"=",
"p_todo",
".",
"completion_date",
"(",
")",
"result",
"=",
"{",
"'source'",
":",
"p_todo",
".",
"source",
"(",
")",
",",
"'text'",
":",
"p_todo",
".",
"text",
"(",
")",
",",
"'priority'",
":",
"p_todo",
".",
"priority",
"(",
")",
",",
"'completed'",
":",
"p_todo",
".",
"is_completed",
"(",
")",
",",
"'tags'",
":",
"p_todo",
".",
"tags",
"(",
")",
",",
"'projects'",
":",
"list",
"(",
"p_todo",
".",
"projects",
"(",
")",
")",
",",
"'contexts'",
":",
"list",
"(",
"p_todo",
".",
"contexts",
"(",
")",
")",
",",
"'creation_date'",
":",
"creation_date",
".",
"isoformat",
"(",
")",
"if",
"creation_date",
"else",
"None",
",",
"'completion_date'",
":",
"completion_date",
".",
"isoformat",
"(",
")",
"if",
"completion_date",
"else",
"None",
"}",
"return",
"result"
] | Converts a Todo instance to a dictionary. | [
"Converts",
"a",
"Todo",
"instance",
"to",
"a",
"dictionary",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/printers/Json.py#L27-L46 | train |
bram85/topydo | topydo/lib/ChangeSet.py | get_backup_path | def get_backup_path():
""" Returns full path and filename of backup file """
dirname, filename = path.split(path.splitext(config().todotxt())[0])
filename = '.' + filename + '.bak'
return path.join(dirname, filename) | python | def get_backup_path():
""" Returns full path and filename of backup file """
dirname, filename = path.split(path.splitext(config().todotxt())[0])
filename = '.' + filename + '.bak'
return path.join(dirname, filename) | [
"def",
"get_backup_path",
"(",
")",
":",
"dirname",
",",
"filename",
"=",
"path",
".",
"split",
"(",
"path",
".",
"splitext",
"(",
"config",
"(",
")",
".",
"todotxt",
"(",
")",
")",
"[",
"0",
"]",
")",
"filename",
"=",
"'.'",
"+",
"filename",
"+",
"'.bak'",
"return",
"path",
".",
"join",
"(",
"dirname",
",",
"filename",
")"
] | Returns full path and filename of backup file | [
"Returns",
"full",
"path",
"and",
"filename",
"of",
"backup",
"file"
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L36-L41 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet._read | def _read(self):
"""
Reads backup file from json_file property and sets backup_dict property
with data decompressed and deserialized from that file. If no usable
data is found backup_dict is set to the empty dict.
"""
self.json_file.seek(0)
try:
data = zlib.decompress(self.json_file.read())
self.backup_dict = json.loads(data.decode('utf-8'))
except (EOFError, zlib.error):
self.backup_dict = {} | python | def _read(self):
"""
Reads backup file from json_file property and sets backup_dict property
with data decompressed and deserialized from that file. If no usable
data is found backup_dict is set to the empty dict.
"""
self.json_file.seek(0)
try:
data = zlib.decompress(self.json_file.read())
self.backup_dict = json.loads(data.decode('utf-8'))
except (EOFError, zlib.error):
self.backup_dict = {} | [
"def",
"_read",
"(",
"self",
")",
":",
"self",
".",
"json_file",
".",
"seek",
"(",
"0",
")",
"try",
":",
"data",
"=",
"zlib",
".",
"decompress",
"(",
"self",
".",
"json_file",
".",
"read",
"(",
")",
")",
"self",
".",
"backup_dict",
"=",
"json",
".",
"loads",
"(",
"data",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"except",
"(",
"EOFError",
",",
"zlib",
".",
"error",
")",
":",
"self",
".",
"backup_dict",
"=",
"{",
"}"
] | Reads backup file from json_file property and sets backup_dict property
with data decompressed and deserialized from that file. If no usable
data is found backup_dict is set to the empty dict. | [
"Reads",
"backup",
"file",
"from",
"json_file",
"property",
"and",
"sets",
"backup_dict",
"property",
"with",
"data",
"decompressed",
"and",
"deserialized",
"from",
"that",
"file",
".",
"If",
"no",
"usable",
"data",
"is",
"found",
"backup_dict",
"is",
"set",
"to",
"the",
"empty",
"dict",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L64-L75 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet._write | def _write(self):
"""
Writes data from backup_dict property in serialized and compressed form
to backup file pointed in json_file property.
"""
self.json_file.seek(0)
self.json_file.truncate()
dump = json.dumps(self.backup_dict)
dump_c = zlib.compress(dump.encode('utf-8'))
self.json_file.write(dump_c) | python | def _write(self):
"""
Writes data from backup_dict property in serialized and compressed form
to backup file pointed in json_file property.
"""
self.json_file.seek(0)
self.json_file.truncate()
dump = json.dumps(self.backup_dict)
dump_c = zlib.compress(dump.encode('utf-8'))
self.json_file.write(dump_c) | [
"def",
"_write",
"(",
"self",
")",
":",
"self",
".",
"json_file",
".",
"seek",
"(",
"0",
")",
"self",
".",
"json_file",
".",
"truncate",
"(",
")",
"dump",
"=",
"json",
".",
"dumps",
"(",
"self",
".",
"backup_dict",
")",
"dump_c",
"=",
"zlib",
".",
"compress",
"(",
"dump",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"self",
".",
"json_file",
".",
"write",
"(",
"dump_c",
")"
] | Writes data from backup_dict property in serialized and compressed form
to backup file pointed in json_file property. | [
"Writes",
"data",
"from",
"backup_dict",
"property",
"in",
"serialized",
"and",
"compressed",
"form",
"to",
"backup",
"file",
"pointed",
"in",
"json_file",
"property",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L77-L86 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet.save | def save(self, p_todolist):
"""
Saves a tuple with archive, todolist and command with its arguments
into the backup file with unix timestamp as the key. Tuple is then
indexed in backup file with combination of hash calculated from
p_todolist and unix timestamp. Backup file is closed afterwards.
"""
self._trim()
current_hash = hash_todolist(p_todolist)
list_todo = (self.todolist.print_todos()+'\n').splitlines(True)
try:
list_archive = (self.archive.print_todos()+'\n').splitlines(True)
except AttributeError:
list_archive = []
self.backup_dict[self.timestamp] = (list_todo, list_archive, self.label)
index = self._get_index()
index.insert(0, (self.timestamp, current_hash))
self._save_index(index)
self._write()
self.close() | python | def save(self, p_todolist):
"""
Saves a tuple with archive, todolist and command with its arguments
into the backup file with unix timestamp as the key. Tuple is then
indexed in backup file with combination of hash calculated from
p_todolist and unix timestamp. Backup file is closed afterwards.
"""
self._trim()
current_hash = hash_todolist(p_todolist)
list_todo = (self.todolist.print_todos()+'\n').splitlines(True)
try:
list_archive = (self.archive.print_todos()+'\n').splitlines(True)
except AttributeError:
list_archive = []
self.backup_dict[self.timestamp] = (list_todo, list_archive, self.label)
index = self._get_index()
index.insert(0, (self.timestamp, current_hash))
self._save_index(index)
self._write()
self.close() | [
"def",
"save",
"(",
"self",
",",
"p_todolist",
")",
":",
"self",
".",
"_trim",
"(",
")",
"current_hash",
"=",
"hash_todolist",
"(",
"p_todolist",
")",
"list_todo",
"=",
"(",
"self",
".",
"todolist",
".",
"print_todos",
"(",
")",
"+",
"'\\n'",
")",
".",
"splitlines",
"(",
"True",
")",
"try",
":",
"list_archive",
"=",
"(",
"self",
".",
"archive",
".",
"print_todos",
"(",
")",
"+",
"'\\n'",
")",
".",
"splitlines",
"(",
"True",
")",
"except",
"AttributeError",
":",
"list_archive",
"=",
"[",
"]",
"self",
".",
"backup_dict",
"[",
"self",
".",
"timestamp",
"]",
"=",
"(",
"list_todo",
",",
"list_archive",
",",
"self",
".",
"label",
")",
"index",
"=",
"self",
".",
"_get_index",
"(",
")",
"index",
".",
"insert",
"(",
"0",
",",
"(",
"self",
".",
"timestamp",
",",
"current_hash",
")",
")",
"self",
".",
"_save_index",
"(",
"index",
")",
"self",
".",
"_write",
"(",
")",
"self",
".",
"close",
"(",
")"
] | Saves a tuple with archive, todolist and command with its arguments
into the backup file with unix timestamp as the key. Tuple is then
indexed in backup file with combination of hash calculated from
p_todolist and unix timestamp. Backup file is closed afterwards. | [
"Saves",
"a",
"tuple",
"with",
"archive",
"todolist",
"and",
"command",
"with",
"its",
"arguments",
"into",
"the",
"backup",
"file",
"with",
"unix",
"timestamp",
"as",
"the",
"key",
".",
"Tuple",
"is",
"then",
"indexed",
"in",
"backup",
"file",
"with",
"combination",
"of",
"hash",
"calculated",
"from",
"p_todolist",
"and",
"unix",
"timestamp",
".",
"Backup",
"file",
"is",
"closed",
"afterwards",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L96-L119 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet.delete | def delete(self, p_timestamp=None, p_write=True):
""" Removes backup from the backup file. """
timestamp = p_timestamp or self.timestamp
index = self._get_index()
try:
del self.backup_dict[timestamp]
index.remove(index[[change[0] for change in index].index(timestamp)])
self._save_index(index)
if p_write:
self._write()
except KeyError:
pass | python | def delete(self, p_timestamp=None, p_write=True):
""" Removes backup from the backup file. """
timestamp = p_timestamp or self.timestamp
index = self._get_index()
try:
del self.backup_dict[timestamp]
index.remove(index[[change[0] for change in index].index(timestamp)])
self._save_index(index)
if p_write:
self._write()
except KeyError:
pass | [
"def",
"delete",
"(",
"self",
",",
"p_timestamp",
"=",
"None",
",",
"p_write",
"=",
"True",
")",
":",
"timestamp",
"=",
"p_timestamp",
"or",
"self",
".",
"timestamp",
"index",
"=",
"self",
".",
"_get_index",
"(",
")",
"try",
":",
"del",
"self",
".",
"backup_dict",
"[",
"timestamp",
"]",
"index",
".",
"remove",
"(",
"index",
"[",
"[",
"change",
"[",
"0",
"]",
"for",
"change",
"in",
"index",
"]",
".",
"index",
"(",
"timestamp",
")",
"]",
")",
"self",
".",
"_save_index",
"(",
"index",
")",
"if",
"p_write",
":",
"self",
".",
"_write",
"(",
")",
"except",
"KeyError",
":",
"pass"
] | Removes backup from the backup file. | [
"Removes",
"backup",
"from",
"the",
"backup",
"file",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L121-L134 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet._trim | def _trim(self):
"""
Removes oldest backups that exceed the limit configured in backup_count
option.
Does not write back to file system, make sure to call self._write()
afterwards.
"""
index = self._get_index()
backup_limit = config().backup_count() - 1
for changeset in index[backup_limit:]:
self.delete(changeset[0], p_write=False) | python | def _trim(self):
"""
Removes oldest backups that exceed the limit configured in backup_count
option.
Does not write back to file system, make sure to call self._write()
afterwards.
"""
index = self._get_index()
backup_limit = config().backup_count() - 1
for changeset in index[backup_limit:]:
self.delete(changeset[0], p_write=False) | [
"def",
"_trim",
"(",
"self",
")",
":",
"index",
"=",
"self",
".",
"_get_index",
"(",
")",
"backup_limit",
"=",
"config",
"(",
")",
".",
"backup_count",
"(",
")",
"-",
"1",
"for",
"changeset",
"in",
"index",
"[",
"backup_limit",
":",
"]",
":",
"self",
".",
"delete",
"(",
"changeset",
"[",
"0",
"]",
",",
"p_write",
"=",
"False",
")"
] | Removes oldest backups that exceed the limit configured in backup_count
option.
Does not write back to file system, make sure to call self._write()
afterwards. | [
"Removes",
"oldest",
"backups",
"that",
"exceed",
"the",
"limit",
"configured",
"in",
"backup_count",
"option",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L152-L164 | train |
bram85/topydo | topydo/lib/ChangeSet.py | ChangeSet.apply | def apply(self, p_todolist, p_archive):
""" Applies backup on supplied p_todolist. """
if self.todolist and p_todolist:
p_todolist.replace(self.todolist.todos())
if self.archive and p_archive:
p_archive.replace(self.archive.todos()) | python | def apply(self, p_todolist, p_archive):
""" Applies backup on supplied p_todolist. """
if self.todolist and p_todolist:
p_todolist.replace(self.todolist.todos())
if self.archive and p_archive:
p_archive.replace(self.archive.todos()) | [
"def",
"apply",
"(",
"self",
",",
"p_todolist",
",",
"p_archive",
")",
":",
"if",
"self",
".",
"todolist",
"and",
"p_todolist",
":",
"p_todolist",
".",
"replace",
"(",
"self",
".",
"todolist",
".",
"todos",
"(",
")",
")",
"if",
"self",
".",
"archive",
"and",
"p_archive",
":",
"p_archive",
".",
"replace",
"(",
"self",
".",
"archive",
".",
"todos",
"(",
")",
")"
] | Applies backup on supplied p_todolist. | [
"Applies",
"backup",
"on",
"supplied",
"p_todolist",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ChangeSet.py#L185-L191 | train |
bram85/topydo | topydo/lib/printers/PrettyPrinter.py | pretty_printer_factory | def pretty_printer_factory(p_todolist, p_additional_filters=None):
""" Returns a pretty printer suitable for the ls and dep subcommands. """
p_additional_filters = p_additional_filters or []
printer = PrettyPrinter()
printer.add_filter(PrettyPrinterNumbers(p_todolist))
for ppf in p_additional_filters:
printer.add_filter(ppf)
# apply colors at the last step, the ANSI codes may confuse the
# preceding filters.
printer.add_filter(PrettyPrinterColorFilter())
return printer | python | def pretty_printer_factory(p_todolist, p_additional_filters=None):
""" Returns a pretty printer suitable for the ls and dep subcommands. """
p_additional_filters = p_additional_filters or []
printer = PrettyPrinter()
printer.add_filter(PrettyPrinterNumbers(p_todolist))
for ppf in p_additional_filters:
printer.add_filter(ppf)
# apply colors at the last step, the ANSI codes may confuse the
# preceding filters.
printer.add_filter(PrettyPrinterColorFilter())
return printer | [
"def",
"pretty_printer_factory",
"(",
"p_todolist",
",",
"p_additional_filters",
"=",
"None",
")",
":",
"p_additional_filters",
"=",
"p_additional_filters",
"or",
"[",
"]",
"printer",
"=",
"PrettyPrinter",
"(",
")",
"printer",
".",
"add_filter",
"(",
"PrettyPrinterNumbers",
"(",
"p_todolist",
")",
")",
"for",
"ppf",
"in",
"p_additional_filters",
":",
"printer",
".",
"add_filter",
"(",
"ppf",
")",
"# apply colors at the last step, the ANSI codes may confuse the",
"# preceding filters.",
"printer",
".",
"add_filter",
"(",
"PrettyPrinterColorFilter",
"(",
")",
")",
"return",
"printer"
] | Returns a pretty printer suitable for the ls and dep subcommands. | [
"Returns",
"a",
"pretty",
"printer",
"suitable",
"for",
"the",
"ls",
"and",
"dep",
"subcommands",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/printers/PrettyPrinter.py#L113-L127 | train |
bram85/topydo | topydo/lib/printers/PrettyPrinter.py | PrettyPrinter.print_todo | def print_todo(self, p_todo):
""" Given a todo item, pretty print it. """
todo_str = p_todo.source()
for ppf in self.filters:
todo_str = ppf.filter(todo_str, p_todo)
return TopydoString(todo_str) | python | def print_todo(self, p_todo):
""" Given a todo item, pretty print it. """
todo_str = p_todo.source()
for ppf in self.filters:
todo_str = ppf.filter(todo_str, p_todo)
return TopydoString(todo_str) | [
"def",
"print_todo",
"(",
"self",
",",
"p_todo",
")",
":",
"todo_str",
"=",
"p_todo",
".",
"source",
"(",
")",
"for",
"ppf",
"in",
"self",
".",
"filters",
":",
"todo_str",
"=",
"ppf",
".",
"filter",
"(",
"todo_str",
",",
"p_todo",
")",
"return",
"TopydoString",
"(",
"todo_str",
")"
] | Given a todo item, pretty print it. | [
"Given",
"a",
"todo",
"item",
"pretty",
"print",
"it",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/printers/PrettyPrinter.py#L72-L79 | train |
bram85/topydo | topydo/lib/Sorter.py | Sorter.group | def group(self, p_todos):
"""
Groups the todos according to the given group string.
"""
# preorder todos for the group sort
p_todos = _apply_sort_functions(p_todos, self.pregroupfunctions)
# initialize result with a single group
result = OrderedDict([((), p_todos)])
for (function, label), _ in self.groupfunctions:
oldresult = result
result = OrderedDict()
for oldkey, oldgroup in oldresult.items():
for key, _group in groupby(oldgroup, function):
newgroup = list(_group)
if not isinstance(key, list):
key = [key]
for subkey in key:
subkey = "{}: {}".format(label, subkey)
newkey = oldkey + (subkey,)
if newkey in result:
result[newkey] = result[newkey] + newgroup
else:
result[newkey] = newgroup
# sort all groups
for key, _group in result.items():
result[key] = self.sort(_group)
return result | python | def group(self, p_todos):
"""
Groups the todos according to the given group string.
"""
# preorder todos for the group sort
p_todos = _apply_sort_functions(p_todos, self.pregroupfunctions)
# initialize result with a single group
result = OrderedDict([((), p_todos)])
for (function, label), _ in self.groupfunctions:
oldresult = result
result = OrderedDict()
for oldkey, oldgroup in oldresult.items():
for key, _group in groupby(oldgroup, function):
newgroup = list(_group)
if not isinstance(key, list):
key = [key]
for subkey in key:
subkey = "{}: {}".format(label, subkey)
newkey = oldkey + (subkey,)
if newkey in result:
result[newkey] = result[newkey] + newgroup
else:
result[newkey] = newgroup
# sort all groups
for key, _group in result.items():
result[key] = self.sort(_group)
return result | [
"def",
"group",
"(",
"self",
",",
"p_todos",
")",
":",
"# preorder todos for the group sort",
"p_todos",
"=",
"_apply_sort_functions",
"(",
"p_todos",
",",
"self",
".",
"pregroupfunctions",
")",
"# initialize result with a single group",
"result",
"=",
"OrderedDict",
"(",
"[",
"(",
"(",
")",
",",
"p_todos",
")",
"]",
")",
"for",
"(",
"function",
",",
"label",
")",
",",
"_",
"in",
"self",
".",
"groupfunctions",
":",
"oldresult",
"=",
"result",
"result",
"=",
"OrderedDict",
"(",
")",
"for",
"oldkey",
",",
"oldgroup",
"in",
"oldresult",
".",
"items",
"(",
")",
":",
"for",
"key",
",",
"_group",
"in",
"groupby",
"(",
"oldgroup",
",",
"function",
")",
":",
"newgroup",
"=",
"list",
"(",
"_group",
")",
"if",
"not",
"isinstance",
"(",
"key",
",",
"list",
")",
":",
"key",
"=",
"[",
"key",
"]",
"for",
"subkey",
"in",
"key",
":",
"subkey",
"=",
"\"{}: {}\"",
".",
"format",
"(",
"label",
",",
"subkey",
")",
"newkey",
"=",
"oldkey",
"+",
"(",
"subkey",
",",
")",
"if",
"newkey",
"in",
"result",
":",
"result",
"[",
"newkey",
"]",
"=",
"result",
"[",
"newkey",
"]",
"+",
"newgroup",
"else",
":",
"result",
"[",
"newkey",
"]",
"=",
"newgroup",
"# sort all groups",
"for",
"key",
",",
"_group",
"in",
"result",
".",
"items",
"(",
")",
":",
"result",
"[",
"key",
"]",
"=",
"self",
".",
"sort",
"(",
"_group",
")",
"return",
"result"
] | Groups the todos according to the given group string. | [
"Groups",
"the",
"todos",
"according",
"to",
"the",
"given",
"group",
"string",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Sorter.py#L237-L270 | train |
bram85/topydo | topydo/lib/ListFormat.py | _strip_placeholder_braces | def _strip_placeholder_braces(p_matchobj):
"""
Returns string with conditional braces around placeholder stripped and
percent sign glued into placeholder character.
Returned string is composed from 'start', 'before', 'placeholder', 'after',
'whitespace', and 'end' match-groups of p_matchobj. Conditional braces are
stripped from 'before' and 'after' groups. 'whitespace', 'start', and 'end'
groups are preserved without any change.
Using this function as an 'repl' argument in re.sub it is possible to turn:
%{(}B{)}
into:
(%B)
"""
before = p_matchobj.group('before') or ''
placeholder = p_matchobj.group('placeholder')
after = p_matchobj.group('after') or ''
whitespace = p_matchobj.group('whitespace') or ''
return before + '%' + placeholder + after + whitespace | python | def _strip_placeholder_braces(p_matchobj):
"""
Returns string with conditional braces around placeholder stripped and
percent sign glued into placeholder character.
Returned string is composed from 'start', 'before', 'placeholder', 'after',
'whitespace', and 'end' match-groups of p_matchobj. Conditional braces are
stripped from 'before' and 'after' groups. 'whitespace', 'start', and 'end'
groups are preserved without any change.
Using this function as an 'repl' argument in re.sub it is possible to turn:
%{(}B{)}
into:
(%B)
"""
before = p_matchobj.group('before') or ''
placeholder = p_matchobj.group('placeholder')
after = p_matchobj.group('after') or ''
whitespace = p_matchobj.group('whitespace') or ''
return before + '%' + placeholder + after + whitespace | [
"def",
"_strip_placeholder_braces",
"(",
"p_matchobj",
")",
":",
"before",
"=",
"p_matchobj",
".",
"group",
"(",
"'before'",
")",
"or",
"''",
"placeholder",
"=",
"p_matchobj",
".",
"group",
"(",
"'placeholder'",
")",
"after",
"=",
"p_matchobj",
".",
"group",
"(",
"'after'",
")",
"or",
"''",
"whitespace",
"=",
"p_matchobj",
".",
"group",
"(",
"'whitespace'",
")",
"or",
"''",
"return",
"before",
"+",
"'%'",
"+",
"placeholder",
"+",
"after",
"+",
"whitespace"
] | Returns string with conditional braces around placeholder stripped and
percent sign glued into placeholder character.
Returned string is composed from 'start', 'before', 'placeholder', 'after',
'whitespace', and 'end' match-groups of p_matchobj. Conditional braces are
stripped from 'before' and 'after' groups. 'whitespace', 'start', and 'end'
groups are preserved without any change.
Using this function as an 'repl' argument in re.sub it is possible to turn:
%{(}B{)}
into:
(%B) | [
"Returns",
"string",
"with",
"conditional",
"braces",
"around",
"placeholder",
"stripped",
"and",
"percent",
"sign",
"glued",
"into",
"placeholder",
"character",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ListFormat.py#L65-L85 | train |
bram85/topydo | topydo/lib/ListFormat.py | _truncate | def _truncate(p_str, p_repl):
"""
Returns p_str with truncated and ended with '...' version of p_repl.
Place of the truncation is calculated depending on p_max_width.
"""
# 4 is for '...' and an extra space at the end
text_lim = _columns() - len(escape_ansi(p_str)) - 4
truncated_str = re.sub(re.escape(p_repl), p_repl[:text_lim] + '...', p_str)
return truncated_str | python | def _truncate(p_str, p_repl):
"""
Returns p_str with truncated and ended with '...' version of p_repl.
Place of the truncation is calculated depending on p_max_width.
"""
# 4 is for '...' and an extra space at the end
text_lim = _columns() - len(escape_ansi(p_str)) - 4
truncated_str = re.sub(re.escape(p_repl), p_repl[:text_lim] + '...', p_str)
return truncated_str | [
"def",
"_truncate",
"(",
"p_str",
",",
"p_repl",
")",
":",
"# 4 is for '...' and an extra space at the end",
"text_lim",
"=",
"_columns",
"(",
")",
"-",
"len",
"(",
"escape_ansi",
"(",
"p_str",
")",
")",
"-",
"4",
"truncated_str",
"=",
"re",
".",
"sub",
"(",
"re",
".",
"escape",
"(",
"p_repl",
")",
",",
"p_repl",
"[",
":",
"text_lim",
"]",
"+",
"'...'",
",",
"p_str",
")",
"return",
"truncated_str"
] | Returns p_str with truncated and ended with '...' version of p_repl.
Place of the truncation is calculated depending on p_max_width. | [
"Returns",
"p_str",
"with",
"truncated",
"and",
"ended",
"with",
"...",
"version",
"of",
"p_repl",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ListFormat.py#L99-L109 | train |
bram85/topydo | topydo/lib/ListFormat.py | ListFormatParser._preprocess_format | def _preprocess_format(self):
"""
Preprocess the format_string attribute.
Splits the format string on each placeholder and returns a list of
tuples containing substring, placeholder name, and function
retrieving content for placeholder (getter).
Relevant placeholder functions (getters) are taken from
'placeholders' attribute which is a dict. If no matching placeholder
is found in 'placeholders' getter is set to None. Getter and
placeholder are also always set to None in first element of the
returned list, because it never contain a real placeholder (read
re.split documentation for further information).
"""
format_split = re.split(r'(?<!\\)%', self.format_string)
preprocessed_format = []
for idx, substr in enumerate(format_split):
if idx == 0:
getter = None
placeholder = None
else:
pattern = MAIN_PATTERN.format(ph=r'\S')
try:
placeholder = re.match(pattern, substr).group('placeholder').strip('[]')
except AttributeError:
placeholder = None
if placeholder == 'S':
self.one_line = True
try:
getter = self.placeholders[placeholder]
except KeyError:
getter = None
substr = re.sub(pattern, '', substr)
format_elem = (substr, placeholder, getter)
preprocessed_format.append(format_elem)
return preprocessed_format | python | def _preprocess_format(self):
"""
Preprocess the format_string attribute.
Splits the format string on each placeholder and returns a list of
tuples containing substring, placeholder name, and function
retrieving content for placeholder (getter).
Relevant placeholder functions (getters) are taken from
'placeholders' attribute which is a dict. If no matching placeholder
is found in 'placeholders' getter is set to None. Getter and
placeholder are also always set to None in first element of the
returned list, because it never contain a real placeholder (read
re.split documentation for further information).
"""
format_split = re.split(r'(?<!\\)%', self.format_string)
preprocessed_format = []
for idx, substr in enumerate(format_split):
if idx == 0:
getter = None
placeholder = None
else:
pattern = MAIN_PATTERN.format(ph=r'\S')
try:
placeholder = re.match(pattern, substr).group('placeholder').strip('[]')
except AttributeError:
placeholder = None
if placeholder == 'S':
self.one_line = True
try:
getter = self.placeholders[placeholder]
except KeyError:
getter = None
substr = re.sub(pattern, '', substr)
format_elem = (substr, placeholder, getter)
preprocessed_format.append(format_elem)
return preprocessed_format | [
"def",
"_preprocess_format",
"(",
"self",
")",
":",
"format_split",
"=",
"re",
".",
"split",
"(",
"r'(?<!\\\\)%'",
",",
"self",
".",
"format_string",
")",
"preprocessed_format",
"=",
"[",
"]",
"for",
"idx",
",",
"substr",
"in",
"enumerate",
"(",
"format_split",
")",
":",
"if",
"idx",
"==",
"0",
":",
"getter",
"=",
"None",
"placeholder",
"=",
"None",
"else",
":",
"pattern",
"=",
"MAIN_PATTERN",
".",
"format",
"(",
"ph",
"=",
"r'\\S'",
")",
"try",
":",
"placeholder",
"=",
"re",
".",
"match",
"(",
"pattern",
",",
"substr",
")",
".",
"group",
"(",
"'placeholder'",
")",
".",
"strip",
"(",
"'[]'",
")",
"except",
"AttributeError",
":",
"placeholder",
"=",
"None",
"if",
"placeholder",
"==",
"'S'",
":",
"self",
".",
"one_line",
"=",
"True",
"try",
":",
"getter",
"=",
"self",
".",
"placeholders",
"[",
"placeholder",
"]",
"except",
"KeyError",
":",
"getter",
"=",
"None",
"substr",
"=",
"re",
".",
"sub",
"(",
"pattern",
",",
"''",
",",
"substr",
")",
"format_elem",
"=",
"(",
"substr",
",",
"placeholder",
",",
"getter",
")",
"preprocessed_format",
".",
"append",
"(",
"format_elem",
")",
"return",
"preprocessed_format"
] | Preprocess the format_string attribute.
Splits the format string on each placeholder and returns a list of
tuples containing substring, placeholder name, and function
retrieving content for placeholder (getter).
Relevant placeholder functions (getters) are taken from
'placeholders' attribute which is a dict. If no matching placeholder
is found in 'placeholders' getter is set to None. Getter and
placeholder are also always set to None in first element of the
returned list, because it never contain a real placeholder (read
re.split documentation for further information). | [
"Preprocess",
"the",
"format_string",
"attribute",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ListFormat.py#L225-L266 | train |
bram85/topydo | topydo/lib/ListFormat.py | ListFormatParser.parse | def parse(self, p_todo):
"""
Returns fully parsed string from 'format_string' attribute with all
placeholders properly substituted by content obtained from p_todo.
It uses preprocessed form of 'format_string' (result of
ListFormatParser._preprocess_format) stored in 'format_list'
attribute.
"""
parsed_list = []
repl_trunc = None
for substr, placeholder, getter in self.format_list:
repl = getter(p_todo) if getter else ''
pattern = MAIN_PATTERN.format(ph=placeholder)
if placeholder == 'S':
repl_trunc = repl
try:
if repl == '':
substr = re.sub(pattern, '', substr)
else:
substr = re.sub(pattern, _strip_placeholder_braces, substr)
substr = re.sub(r'(?<!\\)%({ph}|\[{ph}\])'.format(ph=placeholder), repl, substr)
except re.error:
raise ListFormatError
parsed_list.append(substr)
parsed_str = _unescape_percent_sign(''.join(parsed_list))
parsed_str = _remove_redundant_spaces(parsed_str)
if self.one_line and len(escape_ansi(parsed_str)) >= _columns():
parsed_str = _truncate(parsed_str, repl_trunc)
if re.search('.*\t', parsed_str):
parsed_str = _right_align(parsed_str)
return parsed_str.rstrip() | python | def parse(self, p_todo):
"""
Returns fully parsed string from 'format_string' attribute with all
placeholders properly substituted by content obtained from p_todo.
It uses preprocessed form of 'format_string' (result of
ListFormatParser._preprocess_format) stored in 'format_list'
attribute.
"""
parsed_list = []
repl_trunc = None
for substr, placeholder, getter in self.format_list:
repl = getter(p_todo) if getter else ''
pattern = MAIN_PATTERN.format(ph=placeholder)
if placeholder == 'S':
repl_trunc = repl
try:
if repl == '':
substr = re.sub(pattern, '', substr)
else:
substr = re.sub(pattern, _strip_placeholder_braces, substr)
substr = re.sub(r'(?<!\\)%({ph}|\[{ph}\])'.format(ph=placeholder), repl, substr)
except re.error:
raise ListFormatError
parsed_list.append(substr)
parsed_str = _unescape_percent_sign(''.join(parsed_list))
parsed_str = _remove_redundant_spaces(parsed_str)
if self.one_line and len(escape_ansi(parsed_str)) >= _columns():
parsed_str = _truncate(parsed_str, repl_trunc)
if re.search('.*\t', parsed_str):
parsed_str = _right_align(parsed_str)
return parsed_str.rstrip() | [
"def",
"parse",
"(",
"self",
",",
"p_todo",
")",
":",
"parsed_list",
"=",
"[",
"]",
"repl_trunc",
"=",
"None",
"for",
"substr",
",",
"placeholder",
",",
"getter",
"in",
"self",
".",
"format_list",
":",
"repl",
"=",
"getter",
"(",
"p_todo",
")",
"if",
"getter",
"else",
"''",
"pattern",
"=",
"MAIN_PATTERN",
".",
"format",
"(",
"ph",
"=",
"placeholder",
")",
"if",
"placeholder",
"==",
"'S'",
":",
"repl_trunc",
"=",
"repl",
"try",
":",
"if",
"repl",
"==",
"''",
":",
"substr",
"=",
"re",
".",
"sub",
"(",
"pattern",
",",
"''",
",",
"substr",
")",
"else",
":",
"substr",
"=",
"re",
".",
"sub",
"(",
"pattern",
",",
"_strip_placeholder_braces",
",",
"substr",
")",
"substr",
"=",
"re",
".",
"sub",
"(",
"r'(?<!\\\\)%({ph}|\\[{ph}\\])'",
".",
"format",
"(",
"ph",
"=",
"placeholder",
")",
",",
"repl",
",",
"substr",
")",
"except",
"re",
".",
"error",
":",
"raise",
"ListFormatError",
"parsed_list",
".",
"append",
"(",
"substr",
")",
"parsed_str",
"=",
"_unescape_percent_sign",
"(",
"''",
".",
"join",
"(",
"parsed_list",
")",
")",
"parsed_str",
"=",
"_remove_redundant_spaces",
"(",
"parsed_str",
")",
"if",
"self",
".",
"one_line",
"and",
"len",
"(",
"escape_ansi",
"(",
"parsed_str",
")",
")",
">=",
"_columns",
"(",
")",
":",
"parsed_str",
"=",
"_truncate",
"(",
"parsed_str",
",",
"repl_trunc",
")",
"if",
"re",
".",
"search",
"(",
"'.*\\t'",
",",
"parsed_str",
")",
":",
"parsed_str",
"=",
"_right_align",
"(",
"parsed_str",
")",
"return",
"parsed_str",
".",
"rstrip",
"(",
")"
] | Returns fully parsed string from 'format_string' attribute with all
placeholders properly substituted by content obtained from p_todo.
It uses preprocessed form of 'format_string' (result of
ListFormatParser._preprocess_format) stored in 'format_list'
attribute. | [
"Returns",
"fully",
"parsed",
"string",
"from",
"format_string",
"attribute",
"with",
"all",
"placeholders",
"properly",
"substituted",
"by",
"content",
"obtained",
"from",
"p_todo",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/ListFormat.py#L268-L307 | train |
bram85/topydo | topydo/ui/prompt/Prompt.py | PromptApplication._load_file | def _load_file(self):
"""
Reads the configured todo.txt file and loads it into the todo list
instance.
"""
self.todolist.erase()
self.todolist.add_list(self.todofile.read())
self.completer = PromptCompleter(self.todolist) | python | def _load_file(self):
"""
Reads the configured todo.txt file and loads it into the todo list
instance.
"""
self.todolist.erase()
self.todolist.add_list(self.todofile.read())
self.completer = PromptCompleter(self.todolist) | [
"def",
"_load_file",
"(",
"self",
")",
":",
"self",
".",
"todolist",
".",
"erase",
"(",
")",
"self",
".",
"todolist",
".",
"add_list",
"(",
"self",
".",
"todofile",
".",
"read",
"(",
")",
")",
"self",
".",
"completer",
"=",
"PromptCompleter",
"(",
"self",
".",
"todolist",
")"
] | Reads the configured todo.txt file and loads it into the todo list
instance. | [
"Reads",
"the",
"configured",
"todo",
".",
"txt",
"file",
"and",
"loads",
"it",
"into",
"the",
"todo",
"list",
"instance",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/prompt/Prompt.py#L56-L63 | train |
bram85/topydo | topydo/lib/Command.py | Command.execute | def execute(self):
"""
Execute the command. Intercepts the help subsubcommand to show the help
text.
"""
if self.args and self.argument(0) == "help":
self.error(self.usage() + "\n\n" + self.help())
return False
return True | python | def execute(self):
"""
Execute the command. Intercepts the help subsubcommand to show the help
text.
"""
if self.args and self.argument(0) == "help":
self.error(self.usage() + "\n\n" + self.help())
return False
return True | [
"def",
"execute",
"(",
"self",
")",
":",
"if",
"self",
".",
"args",
"and",
"self",
".",
"argument",
"(",
"0",
")",
"==",
"\"help\"",
":",
"self",
".",
"error",
"(",
"self",
".",
"usage",
"(",
")",
"+",
"\"\\n\\n\"",
"+",
"self",
".",
"help",
"(",
")",
")",
"return",
"False",
"return",
"True"
] | Execute the command. Intercepts the help subsubcommand to show the help
text. | [
"Execute",
"the",
"command",
".",
"Intercepts",
"the",
"help",
"subsubcommand",
"to",
"show",
"the",
"help",
"text",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Command.py#L59-L68 | train |
bram85/topydo | topydo/lib/Command.py | Command.argument | def argument(self, p_number):
""" Retrieves a value from the argument list at the given position. """
try:
return self.args[p_number]
except IndexError as ie:
raise InvalidCommandArgument from ie | python | def argument(self, p_number):
""" Retrieves a value from the argument list at the given position. """
try:
return self.args[p_number]
except IndexError as ie:
raise InvalidCommandArgument from ie | [
"def",
"argument",
"(",
"self",
",",
"p_number",
")",
":",
"try",
":",
"return",
"self",
".",
"args",
"[",
"p_number",
"]",
"except",
"IndexError",
"as",
"ie",
":",
"raise",
"InvalidCommandArgument",
"from",
"ie"
] | Retrieves a value from the argument list at the given position. | [
"Retrieves",
"a",
"value",
"from",
"the",
"argument",
"list",
"at",
"the",
"given",
"position",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Command.py#L70-L75 | train |
bram85/topydo | topydo/lib/Config.py | config | def config(p_path=None, p_overrides=None):
"""
Retrieve the config instance.
If a path is given, the instance is overwritten by the one that supplies an
additional filename (for testability). Moreover, no other configuration
files will be read when a path is given.
Overrides will discard a setting in any configuration file and use the
passed value instead. Structure: (section, option) => value
The previous configuration instance will be discarded.
"""
if not config.instance or p_path is not None or p_overrides is not None:
try:
config.instance = _Config(p_path, p_overrides)
except configparser.ParsingError as perr:
raise ConfigError(str(perr)) from perr
return config.instance | python | def config(p_path=None, p_overrides=None):
"""
Retrieve the config instance.
If a path is given, the instance is overwritten by the one that supplies an
additional filename (for testability). Moreover, no other configuration
files will be read when a path is given.
Overrides will discard a setting in any configuration file and use the
passed value instead. Structure: (section, option) => value
The previous configuration instance will be discarded.
"""
if not config.instance or p_path is not None or p_overrides is not None:
try:
config.instance = _Config(p_path, p_overrides)
except configparser.ParsingError as perr:
raise ConfigError(str(perr)) from perr
return config.instance | [
"def",
"config",
"(",
"p_path",
"=",
"None",
",",
"p_overrides",
"=",
"None",
")",
":",
"if",
"not",
"config",
".",
"instance",
"or",
"p_path",
"is",
"not",
"None",
"or",
"p_overrides",
"is",
"not",
"None",
":",
"try",
":",
"config",
".",
"instance",
"=",
"_Config",
"(",
"p_path",
",",
"p_overrides",
")",
"except",
"configparser",
".",
"ParsingError",
"as",
"perr",
":",
"raise",
"ConfigError",
"(",
"str",
"(",
"perr",
")",
")",
"from",
"perr",
"return",
"config",
".",
"instance"
] | Retrieve the config instance.
If a path is given, the instance is overwritten by the one that supplies an
additional filename (for testability). Moreover, no other configuration
files will be read when a path is given.
Overrides will discard a setting in any configuration file and use the
passed value instead. Structure: (section, option) => value
The previous configuration instance will be discarded. | [
"Retrieve",
"the",
"config",
"instance",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L486-L504 | train |
bram85/topydo | topydo/lib/Config.py | _Config.colors | def colors(self, p_hint_possible=True):
"""
Returns 0, 16 or 256 representing the number of colors that should be
used in the output.
A hint can be passed whether the device that will output the text
supports colors.
"""
lookup = {
'false': 0,
'no': 0,
'0': 0,
'1': 16,
'true': 16,
'yes': 16,
'16': 16,
'256': 256,
}
try:
forced = self.cp.get('topydo', 'force_colors') == '1'
except ValueError:
forced = self.defaults['topydo']['force_colors'] == '1'
try:
colors = lookup[self.cp.get('topydo', 'colors').lower()] # pylint: disable=no-member
except ValueError:
colors = lookup[self.defaults['topydo']['colors'].lower()] # pylint: disable=no-member
except KeyError:
# for invalid values or 'auto'
colors = 16 if p_hint_possible else 0
# disable colors when no colors are enforced on the commandline and
# color support is determined automatically
return 0 if not forced and not p_hint_possible else colors | python | def colors(self, p_hint_possible=True):
"""
Returns 0, 16 or 256 representing the number of colors that should be
used in the output.
A hint can be passed whether the device that will output the text
supports colors.
"""
lookup = {
'false': 0,
'no': 0,
'0': 0,
'1': 16,
'true': 16,
'yes': 16,
'16': 16,
'256': 256,
}
try:
forced = self.cp.get('topydo', 'force_colors') == '1'
except ValueError:
forced = self.defaults['topydo']['force_colors'] == '1'
try:
colors = lookup[self.cp.get('topydo', 'colors').lower()] # pylint: disable=no-member
except ValueError:
colors = lookup[self.defaults['topydo']['colors'].lower()] # pylint: disable=no-member
except KeyError:
# for invalid values or 'auto'
colors = 16 if p_hint_possible else 0
# disable colors when no colors are enforced on the commandline and
# color support is determined automatically
return 0 if not forced and not p_hint_possible else colors | [
"def",
"colors",
"(",
"self",
",",
"p_hint_possible",
"=",
"True",
")",
":",
"lookup",
"=",
"{",
"'false'",
":",
"0",
",",
"'no'",
":",
"0",
",",
"'0'",
":",
"0",
",",
"'1'",
":",
"16",
",",
"'true'",
":",
"16",
",",
"'yes'",
":",
"16",
",",
"'16'",
":",
"16",
",",
"'256'",
":",
"256",
",",
"}",
"try",
":",
"forced",
"=",
"self",
".",
"cp",
".",
"get",
"(",
"'topydo'",
",",
"'force_colors'",
")",
"==",
"'1'",
"except",
"ValueError",
":",
"forced",
"=",
"self",
".",
"defaults",
"[",
"'topydo'",
"]",
"[",
"'force_colors'",
"]",
"==",
"'1'",
"try",
":",
"colors",
"=",
"lookup",
"[",
"self",
".",
"cp",
".",
"get",
"(",
"'topydo'",
",",
"'colors'",
")",
".",
"lower",
"(",
")",
"]",
"# pylint: disable=no-member",
"except",
"ValueError",
":",
"colors",
"=",
"lookup",
"[",
"self",
".",
"defaults",
"[",
"'topydo'",
"]",
"[",
"'colors'",
"]",
".",
"lower",
"(",
")",
"]",
"# pylint: disable=no-member",
"except",
"KeyError",
":",
"# for invalid values or 'auto'",
"colors",
"=",
"16",
"if",
"p_hint_possible",
"else",
"0",
"# disable colors when no colors are enforced on the commandline and",
"# color support is determined automatically",
"return",
"0",
"if",
"not",
"forced",
"and",
"not",
"p_hint_possible",
"else",
"colors"
] | Returns 0, 16 or 256 representing the number of colors that should be
used in the output.
A hint can be passed whether the device that will output the text
supports colors. | [
"Returns",
"0",
"16",
"or",
"256",
"representing",
"the",
"number",
"of",
"colors",
"that",
"should",
"be",
"used",
"in",
"the",
"output",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L209-L243 | train |
bram85/topydo | topydo/lib/Config.py | _Config.hidden_tags | def hidden_tags(self):
""" Returns a list of tags to be hidden from the 'ls' output. """
hidden_tags = self.cp.get('ls', 'hide_tags')
# pylint: disable=no-member
return [] if hidden_tags == '' else [tag.strip() for tag in
hidden_tags.split(',')] | python | def hidden_tags(self):
""" Returns a list of tags to be hidden from the 'ls' output. """
hidden_tags = self.cp.get('ls', 'hide_tags')
# pylint: disable=no-member
return [] if hidden_tags == '' else [tag.strip() for tag in
hidden_tags.split(',')] | [
"def",
"hidden_tags",
"(",
"self",
")",
":",
"hidden_tags",
"=",
"self",
".",
"cp",
".",
"get",
"(",
"'ls'",
",",
"'hide_tags'",
")",
"# pylint: disable=no-member",
"return",
"[",
"]",
"if",
"hidden_tags",
"==",
"''",
"else",
"[",
"tag",
".",
"strip",
"(",
")",
"for",
"tag",
"in",
"hidden_tags",
".",
"split",
"(",
"','",
")",
"]"
] | Returns a list of tags to be hidden from the 'ls' output. | [
"Returns",
"a",
"list",
"of",
"tags",
"to",
"be",
"hidden",
"from",
"the",
"ls",
"output",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L322-L327 | train |
bram85/topydo | topydo/lib/Config.py | _Config.hidden_item_tags | def hidden_item_tags(self):
""" Returns a list of tags which hide an item from the 'ls' output. """
hidden_item_tags = self.cp.get('ls', 'hidden_item_tags')
# pylint: disable=no-member
return [] if hidden_item_tags == '' else [tag.strip() for tag in
hidden_item_tags.split(',')] | python | def hidden_item_tags(self):
""" Returns a list of tags which hide an item from the 'ls' output. """
hidden_item_tags = self.cp.get('ls', 'hidden_item_tags')
# pylint: disable=no-member
return [] if hidden_item_tags == '' else [tag.strip() for tag in
hidden_item_tags.split(',')] | [
"def",
"hidden_item_tags",
"(",
"self",
")",
":",
"hidden_item_tags",
"=",
"self",
".",
"cp",
".",
"get",
"(",
"'ls'",
",",
"'hidden_item_tags'",
")",
"# pylint: disable=no-member",
"return",
"[",
"]",
"if",
"hidden_item_tags",
"==",
"''",
"else",
"[",
"tag",
".",
"strip",
"(",
")",
"for",
"tag",
"in",
"hidden_item_tags",
".",
"split",
"(",
"','",
")",
"]"
] | Returns a list of tags which hide an item from the 'ls' output. | [
"Returns",
"a",
"list",
"of",
"tags",
"which",
"hide",
"an",
"item",
"from",
"the",
"ls",
"output",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L329-L334 | train |
bram85/topydo | topydo/lib/Config.py | _Config.priority_color | def priority_color(self, p_priority):
"""
Returns a dict with priorities as keys and color numbers as value.
"""
def _str_to_dict(p_string):
pri_colors_dict = dict()
for pri_color in p_string.split(','):
pri, color = pri_color.split(':')
pri_colors_dict[pri] = Color(color)
return pri_colors_dict
try:
pri_colors_str = self.cp.get('colorscheme', 'priority_colors')
if pri_colors_str == '':
pri_colors_dict = _str_to_dict('A:-1,B:-1,C:-1')
else:
pri_colors_dict = _str_to_dict(pri_colors_str)
except ValueError:
pri_colors_dict = _str_to_dict(self.defaults['colorscheme']['priority_colors'])
return pri_colors_dict[p_priority] if p_priority in pri_colors_dict else Color('NEUTRAL') | python | def priority_color(self, p_priority):
"""
Returns a dict with priorities as keys and color numbers as value.
"""
def _str_to_dict(p_string):
pri_colors_dict = dict()
for pri_color in p_string.split(','):
pri, color = pri_color.split(':')
pri_colors_dict[pri] = Color(color)
return pri_colors_dict
try:
pri_colors_str = self.cp.get('colorscheme', 'priority_colors')
if pri_colors_str == '':
pri_colors_dict = _str_to_dict('A:-1,B:-1,C:-1')
else:
pri_colors_dict = _str_to_dict(pri_colors_str)
except ValueError:
pri_colors_dict = _str_to_dict(self.defaults['colorscheme']['priority_colors'])
return pri_colors_dict[p_priority] if p_priority in pri_colors_dict else Color('NEUTRAL') | [
"def",
"priority_color",
"(",
"self",
",",
"p_priority",
")",
":",
"def",
"_str_to_dict",
"(",
"p_string",
")",
":",
"pri_colors_dict",
"=",
"dict",
"(",
")",
"for",
"pri_color",
"in",
"p_string",
".",
"split",
"(",
"','",
")",
":",
"pri",
",",
"color",
"=",
"pri_color",
".",
"split",
"(",
"':'",
")",
"pri_colors_dict",
"[",
"pri",
"]",
"=",
"Color",
"(",
"color",
")",
"return",
"pri_colors_dict",
"try",
":",
"pri_colors_str",
"=",
"self",
".",
"cp",
".",
"get",
"(",
"'colorscheme'",
",",
"'priority_colors'",
")",
"if",
"pri_colors_str",
"==",
"''",
":",
"pri_colors_dict",
"=",
"_str_to_dict",
"(",
"'A:-1,B:-1,C:-1'",
")",
"else",
":",
"pri_colors_dict",
"=",
"_str_to_dict",
"(",
"pri_colors_str",
")",
"except",
"ValueError",
":",
"pri_colors_dict",
"=",
"_str_to_dict",
"(",
"self",
".",
"defaults",
"[",
"'colorscheme'",
"]",
"[",
"'priority_colors'",
"]",
")",
"return",
"pri_colors_dict",
"[",
"p_priority",
"]",
"if",
"p_priority",
"in",
"pri_colors_dict",
"else",
"Color",
"(",
"'NEUTRAL'",
")"
] | Returns a dict with priorities as keys and color numbers as value. | [
"Returns",
"a",
"dict",
"with",
"priorities",
"as",
"keys",
"and",
"color",
"numbers",
"as",
"value",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L337-L359 | train |
bram85/topydo | topydo/lib/Config.py | _Config.aliases | def aliases(self):
"""
Returns dict with aliases names as keys and pairs of actual
subcommand and alias args as values.
"""
aliases = self.cp.items('aliases')
alias_dict = dict()
for alias, meaning in aliases:
try:
meaning = shlex.split(meaning)
real_subcommand = meaning[0]
alias_args = meaning[1:]
alias_dict[alias] = (real_subcommand, alias_args)
except ValueError as verr:
alias_dict[alias] = str(verr)
return alias_dict | python | def aliases(self):
"""
Returns dict with aliases names as keys and pairs of actual
subcommand and alias args as values.
"""
aliases = self.cp.items('aliases')
alias_dict = dict()
for alias, meaning in aliases:
try:
meaning = shlex.split(meaning)
real_subcommand = meaning[0]
alias_args = meaning[1:]
alias_dict[alias] = (real_subcommand, alias_args)
except ValueError as verr:
alias_dict[alias] = str(verr)
return alias_dict | [
"def",
"aliases",
"(",
"self",
")",
":",
"aliases",
"=",
"self",
".",
"cp",
".",
"items",
"(",
"'aliases'",
")",
"alias_dict",
"=",
"dict",
"(",
")",
"for",
"alias",
",",
"meaning",
"in",
"aliases",
":",
"try",
":",
"meaning",
"=",
"shlex",
".",
"split",
"(",
"meaning",
")",
"real_subcommand",
"=",
"meaning",
"[",
"0",
"]",
"alias_args",
"=",
"meaning",
"[",
"1",
":",
"]",
"alias_dict",
"[",
"alias",
"]",
"=",
"(",
"real_subcommand",
",",
"alias_args",
")",
"except",
"ValueError",
"as",
"verr",
":",
"alias_dict",
"[",
"alias",
"]",
"=",
"str",
"(",
"verr",
")",
"return",
"alias_dict"
] | Returns dict with aliases names as keys and pairs of actual
subcommand and alias args as values. | [
"Returns",
"dict",
"with",
"aliases",
"names",
"as",
"keys",
"and",
"pairs",
"of",
"actual",
"subcommand",
"and",
"alias",
"args",
"as",
"values",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L404-L421 | train |
bram85/topydo | topydo/lib/Config.py | _Config.column_keymap | def column_keymap(self):
""" Returns keymap and keystates used in column mode """
keystates = set()
shortcuts = self.cp.items('column_keymap')
keymap_dict = dict(shortcuts)
for combo, action in shortcuts:
# add all possible prefixes to keystates
combo_as_list = re.split('(<[A-Z].+?>|.)', combo)[1::2]
if len(combo_as_list) > 1:
keystates |= set(accumulate(combo_as_list[:-1]))
if action in ['pri', 'postpone', 'postpone_s']:
keystates.add(combo)
if action == 'pri':
for c in ascii_lowercase:
keymap_dict[combo + c] = 'cmd pri {} ' + c
return (keymap_dict, keystates) | python | def column_keymap(self):
""" Returns keymap and keystates used in column mode """
keystates = set()
shortcuts = self.cp.items('column_keymap')
keymap_dict = dict(shortcuts)
for combo, action in shortcuts:
# add all possible prefixes to keystates
combo_as_list = re.split('(<[A-Z].+?>|.)', combo)[1::2]
if len(combo_as_list) > 1:
keystates |= set(accumulate(combo_as_list[:-1]))
if action in ['pri', 'postpone', 'postpone_s']:
keystates.add(combo)
if action == 'pri':
for c in ascii_lowercase:
keymap_dict[combo + c] = 'cmd pri {} ' + c
return (keymap_dict, keystates) | [
"def",
"column_keymap",
"(",
"self",
")",
":",
"keystates",
"=",
"set",
"(",
")",
"shortcuts",
"=",
"self",
".",
"cp",
".",
"items",
"(",
"'column_keymap'",
")",
"keymap_dict",
"=",
"dict",
"(",
"shortcuts",
")",
"for",
"combo",
",",
"action",
"in",
"shortcuts",
":",
"# add all possible prefixes to keystates",
"combo_as_list",
"=",
"re",
".",
"split",
"(",
"'(<[A-Z].+?>|.)'",
",",
"combo",
")",
"[",
"1",
":",
":",
"2",
"]",
"if",
"len",
"(",
"combo_as_list",
")",
">",
"1",
":",
"keystates",
"|=",
"set",
"(",
"accumulate",
"(",
"combo_as_list",
"[",
":",
"-",
"1",
"]",
")",
")",
"if",
"action",
"in",
"[",
"'pri'",
",",
"'postpone'",
",",
"'postpone_s'",
"]",
":",
"keystates",
".",
"add",
"(",
"combo",
")",
"if",
"action",
"==",
"'pri'",
":",
"for",
"c",
"in",
"ascii_lowercase",
":",
"keymap_dict",
"[",
"combo",
"+",
"c",
"]",
"=",
"'cmd pri {} '",
"+",
"c",
"return",
"(",
"keymap_dict",
",",
"keystates",
")"
] | Returns keymap and keystates used in column mode | [
"Returns",
"keymap",
"and",
"keystates",
"used",
"in",
"column",
"mode"
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L440-L460 | train |
bram85/topydo | topydo/lib/Config.py | _Config.editor | def editor(self):
"""
Returns the editor to invoke. It returns a list with the command in
the first position and its arguments in the remainder.
"""
result = 'vi'
if 'TOPYDO_EDITOR' in os.environ and os.environ['TOPYDO_EDITOR']:
result = os.environ['TOPYDO_EDITOR']
else:
try:
result = str(self.cp.get('edit', 'editor'))
except configparser.NoOptionError:
if 'EDITOR' in os.environ and os.environ['EDITOR']:
result = os.environ['EDITOR']
return shlex.split(result) | python | def editor(self):
"""
Returns the editor to invoke. It returns a list with the command in
the first position and its arguments in the remainder.
"""
result = 'vi'
if 'TOPYDO_EDITOR' in os.environ and os.environ['TOPYDO_EDITOR']:
result = os.environ['TOPYDO_EDITOR']
else:
try:
result = str(self.cp.get('edit', 'editor'))
except configparser.NoOptionError:
if 'EDITOR' in os.environ and os.environ['EDITOR']:
result = os.environ['EDITOR']
return shlex.split(result) | [
"def",
"editor",
"(",
"self",
")",
":",
"result",
"=",
"'vi'",
"if",
"'TOPYDO_EDITOR'",
"in",
"os",
".",
"environ",
"and",
"os",
".",
"environ",
"[",
"'TOPYDO_EDITOR'",
"]",
":",
"result",
"=",
"os",
".",
"environ",
"[",
"'TOPYDO_EDITOR'",
"]",
"else",
":",
"try",
":",
"result",
"=",
"str",
"(",
"self",
".",
"cp",
".",
"get",
"(",
"'edit'",
",",
"'editor'",
")",
")",
"except",
"configparser",
".",
"NoOptionError",
":",
"if",
"'EDITOR'",
"in",
"os",
".",
"environ",
"and",
"os",
".",
"environ",
"[",
"'EDITOR'",
"]",
":",
"result",
"=",
"os",
".",
"environ",
"[",
"'EDITOR'",
"]",
"return",
"shlex",
".",
"split",
"(",
"result",
")"
] | Returns the editor to invoke. It returns a list with the command in
the first position and its arguments in the remainder. | [
"Returns",
"the",
"editor",
"to",
"invoke",
".",
"It",
"returns",
"a",
"list",
"with",
"the",
"command",
"in",
"the",
"first",
"position",
"and",
"its",
"arguments",
"in",
"the",
"remainder",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Config.py#L462-L477 | train |
bram85/topydo | topydo/commands/AddCommand.py | AddCommand.execute | def execute(self):
""" Adds a todo item to the list. """
if not super().execute():
return False
self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
self._process_flags()
if self.from_file:
try:
new_todos = self.get_todos_from_file()
for todo in new_todos:
self._add_todo(todo)
except (IOError, OSError):
self.error('File not found: ' + self.from_file)
else:
if self.text:
self._add_todo(self.text)
else:
self.error(self.usage()) | python | def execute(self):
""" Adds a todo item to the list. """
if not super().execute():
return False
self.printer.add_filter(PrettyPrinterNumbers(self.todolist))
self._process_flags()
if self.from_file:
try:
new_todos = self.get_todos_from_file()
for todo in new_todos:
self._add_todo(todo)
except (IOError, OSError):
self.error('File not found: ' + self.from_file)
else:
if self.text:
self._add_todo(self.text)
else:
self.error(self.usage()) | [
"def",
"execute",
"(",
"self",
")",
":",
"if",
"not",
"super",
"(",
")",
".",
"execute",
"(",
")",
":",
"return",
"False",
"self",
".",
"printer",
".",
"add_filter",
"(",
"PrettyPrinterNumbers",
"(",
"self",
".",
"todolist",
")",
")",
"self",
".",
"_process_flags",
"(",
")",
"if",
"self",
".",
"from_file",
":",
"try",
":",
"new_todos",
"=",
"self",
".",
"get_todos_from_file",
"(",
")",
"for",
"todo",
"in",
"new_todos",
":",
"self",
".",
"_add_todo",
"(",
"todo",
")",
"except",
"(",
"IOError",
",",
"OSError",
")",
":",
"self",
".",
"error",
"(",
"'File not found: '",
"+",
"self",
".",
"from_file",
")",
"else",
":",
"if",
"self",
".",
"text",
":",
"self",
".",
"_add_todo",
"(",
"self",
".",
"text",
")",
"else",
":",
"self",
".",
"error",
"(",
"self",
".",
"usage",
"(",
")",
")"
] | Adds a todo item to the list. | [
"Adds",
"a",
"todo",
"item",
"to",
"the",
"list",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/commands/AddCommand.py#L80-L100 | train |
bram85/topydo | topydo/lib/Recurrence.py | advance_recurring_todo | def advance_recurring_todo(p_todo, p_offset=None, p_strict=False):
"""
Given a Todo item, return a new instance of a Todo item with the dates
shifted according to the recurrence rule.
Strict means that the real due date is taken as a offset, not today or a
future date to determine the offset.
When the todo item has no due date, then the date is used passed by the
caller (defaulting to today).
When no recurrence tag is present, an exception is raised.
"""
todo = Todo(p_todo.source())
pattern = todo.tag_value('rec')
if not pattern:
raise NoRecurrenceException()
elif pattern.startswith('+'):
p_strict = True
# strip off the +
pattern = pattern[1:]
if p_strict:
offset = p_todo.due_date() or p_offset or date.today()
else:
offset = p_offset or date.today()
length = todo.length()
new_due = relative_date_to_date(pattern, offset)
if not new_due:
raise NoRecurrenceException()
# pylint: disable=E1103
todo.set_tag(config().tag_due(), new_due.isoformat())
if todo.start_date():
new_start = new_due - timedelta(length)
todo.set_tag(config().tag_start(), new_start.isoformat())
todo.set_creation_date(date.today())
return todo | python | def advance_recurring_todo(p_todo, p_offset=None, p_strict=False):
"""
Given a Todo item, return a new instance of a Todo item with the dates
shifted according to the recurrence rule.
Strict means that the real due date is taken as a offset, not today or a
future date to determine the offset.
When the todo item has no due date, then the date is used passed by the
caller (defaulting to today).
When no recurrence tag is present, an exception is raised.
"""
todo = Todo(p_todo.source())
pattern = todo.tag_value('rec')
if not pattern:
raise NoRecurrenceException()
elif pattern.startswith('+'):
p_strict = True
# strip off the +
pattern = pattern[1:]
if p_strict:
offset = p_todo.due_date() or p_offset or date.today()
else:
offset = p_offset or date.today()
length = todo.length()
new_due = relative_date_to_date(pattern, offset)
if not new_due:
raise NoRecurrenceException()
# pylint: disable=E1103
todo.set_tag(config().tag_due(), new_due.isoformat())
if todo.start_date():
new_start = new_due - timedelta(length)
todo.set_tag(config().tag_start(), new_start.isoformat())
todo.set_creation_date(date.today())
return todo | [
"def",
"advance_recurring_todo",
"(",
"p_todo",
",",
"p_offset",
"=",
"None",
",",
"p_strict",
"=",
"False",
")",
":",
"todo",
"=",
"Todo",
"(",
"p_todo",
".",
"source",
"(",
")",
")",
"pattern",
"=",
"todo",
".",
"tag_value",
"(",
"'rec'",
")",
"if",
"not",
"pattern",
":",
"raise",
"NoRecurrenceException",
"(",
")",
"elif",
"pattern",
".",
"startswith",
"(",
"'+'",
")",
":",
"p_strict",
"=",
"True",
"# strip off the +",
"pattern",
"=",
"pattern",
"[",
"1",
":",
"]",
"if",
"p_strict",
":",
"offset",
"=",
"p_todo",
".",
"due_date",
"(",
")",
"or",
"p_offset",
"or",
"date",
".",
"today",
"(",
")",
"else",
":",
"offset",
"=",
"p_offset",
"or",
"date",
".",
"today",
"(",
")",
"length",
"=",
"todo",
".",
"length",
"(",
")",
"new_due",
"=",
"relative_date_to_date",
"(",
"pattern",
",",
"offset",
")",
"if",
"not",
"new_due",
":",
"raise",
"NoRecurrenceException",
"(",
")",
"# pylint: disable=E1103",
"todo",
".",
"set_tag",
"(",
"config",
"(",
")",
".",
"tag_due",
"(",
")",
",",
"new_due",
".",
"isoformat",
"(",
")",
")",
"if",
"todo",
".",
"start_date",
"(",
")",
":",
"new_start",
"=",
"new_due",
"-",
"timedelta",
"(",
"length",
")",
"todo",
".",
"set_tag",
"(",
"config",
"(",
")",
".",
"tag_start",
"(",
")",
",",
"new_start",
".",
"isoformat",
"(",
")",
")",
"todo",
".",
"set_creation_date",
"(",
"date",
".",
"today",
"(",
")",
")",
"return",
"todo"
] | Given a Todo item, return a new instance of a Todo item with the dates
shifted according to the recurrence rule.
Strict means that the real due date is taken as a offset, not today or a
future date to determine the offset.
When the todo item has no due date, then the date is used passed by the
caller (defaulting to today).
When no recurrence tag is present, an exception is raised. | [
"Given",
"a",
"Todo",
"item",
"return",
"a",
"new",
"instance",
"of",
"a",
"Todo",
"item",
"with",
"the",
"dates",
"shifted",
"according",
"to",
"the",
"recurrence",
"rule",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Recurrence.py#L30-L73 | train |
bram85/topydo | topydo/lib/HashListValues.py | _get_table_size | def _get_table_size(p_alphabet, p_num):
"""
Returns a prime number that is suitable for the hash table size. The size
is dependent on the alphabet used, and the number of items that need to be
hashed. The table size is at least 100 times larger than the number of
items to be hashed, to avoid collisions.
When the alphabet is too little or too large, then _TableSizeException is
raised. Currently an alphabet of 10 to 40 characters is supported.
"""
try:
for width, size in sorted(_TABLE_SIZES[len(p_alphabet)].items()):
if p_num < size * 0.01:
return width, size
except KeyError:
pass
raise _TableSizeException('Could not find appropriate table size for given alphabet') | python | def _get_table_size(p_alphabet, p_num):
"""
Returns a prime number that is suitable for the hash table size. The size
is dependent on the alphabet used, and the number of items that need to be
hashed. The table size is at least 100 times larger than the number of
items to be hashed, to avoid collisions.
When the alphabet is too little or too large, then _TableSizeException is
raised. Currently an alphabet of 10 to 40 characters is supported.
"""
try:
for width, size in sorted(_TABLE_SIZES[len(p_alphabet)].items()):
if p_num < size * 0.01:
return width, size
except KeyError:
pass
raise _TableSizeException('Could not find appropriate table size for given alphabet') | [
"def",
"_get_table_size",
"(",
"p_alphabet",
",",
"p_num",
")",
":",
"try",
":",
"for",
"width",
",",
"size",
"in",
"sorted",
"(",
"_TABLE_SIZES",
"[",
"len",
"(",
"p_alphabet",
")",
"]",
".",
"items",
"(",
")",
")",
":",
"if",
"p_num",
"<",
"size",
"*",
"0.01",
":",
"return",
"width",
",",
"size",
"except",
"KeyError",
":",
"pass",
"raise",
"_TableSizeException",
"(",
"'Could not find appropriate table size for given alphabet'",
")"
] | Returns a prime number that is suitable for the hash table size. The size
is dependent on the alphabet used, and the number of items that need to be
hashed. The table size is at least 100 times larger than the number of
items to be hashed, to avoid collisions.
When the alphabet is too little or too large, then _TableSizeException is
raised. Currently an alphabet of 10 to 40 characters is supported. | [
"Returns",
"a",
"prime",
"number",
"that",
"is",
"suitable",
"for",
"the",
"hash",
"table",
"size",
".",
"The",
"size",
"is",
"dependent",
"on",
"the",
"alphabet",
"used",
"and",
"the",
"number",
"of",
"items",
"that",
"need",
"to",
"be",
"hashed",
".",
"The",
"table",
"size",
"is",
"at",
"least",
"100",
"times",
"larger",
"than",
"the",
"number",
"of",
"items",
"to",
"be",
"hashed",
"to",
"avoid",
"collisions",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/HashListValues.py#L79-L96 | train |
bram85/topydo | topydo/lib/HashListValues.py | hash_list_values | def hash_list_values(p_list, p_key=lambda i: i): # pragma: no branch
"""
Calculates a unique value for each item in the list, these can be used as
identifiers.
The value is based on hashing an item using the p_key function.
Suitable for lists not larger than approx. 16K items.
Returns a tuple with the status and a list of tuples where each item is
combined with the ID.
"""
def to_base(p_alphabet, p_value):
"""
Converts integer to text ID with characters from the given alphabet.
Based on answer at
https://stackoverflow.com/questions/1181919/python-base-36-encoding
"""
result = ''
while p_value:
p_value, i = divmod(p_value, len(p_alphabet))
result = p_alphabet[i] + result
return result or p_alphabet[0]
result = []
used = set()
alphabet = config().identifier_alphabet()
try:
_, size = _get_table_size(alphabet, len(p_list))
except _TableSizeException:
alphabet = _DEFAULT_ALPHABET
_, size = _get_table_size(alphabet, len(p_list))
for item in p_list:
# obtain the to-be-hashed value
raw_value = p_key(item)
# hash
hasher = sha1()
hasher.update(raw_value.encode('utf-8'))
hash_value = int(hasher.hexdigest(), 16) % size
# resolve possible collisions
while hash_value in used:
hash_value = (hash_value + 1) % size
used.add(hash_value)
result.append((item, to_base(alphabet, hash_value)))
return result | python | def hash_list_values(p_list, p_key=lambda i: i): # pragma: no branch
"""
Calculates a unique value for each item in the list, these can be used as
identifiers.
The value is based on hashing an item using the p_key function.
Suitable for lists not larger than approx. 16K items.
Returns a tuple with the status and a list of tuples where each item is
combined with the ID.
"""
def to_base(p_alphabet, p_value):
"""
Converts integer to text ID with characters from the given alphabet.
Based on answer at
https://stackoverflow.com/questions/1181919/python-base-36-encoding
"""
result = ''
while p_value:
p_value, i = divmod(p_value, len(p_alphabet))
result = p_alphabet[i] + result
return result or p_alphabet[0]
result = []
used = set()
alphabet = config().identifier_alphabet()
try:
_, size = _get_table_size(alphabet, len(p_list))
except _TableSizeException:
alphabet = _DEFAULT_ALPHABET
_, size = _get_table_size(alphabet, len(p_list))
for item in p_list:
# obtain the to-be-hashed value
raw_value = p_key(item)
# hash
hasher = sha1()
hasher.update(raw_value.encode('utf-8'))
hash_value = int(hasher.hexdigest(), 16) % size
# resolve possible collisions
while hash_value in used:
hash_value = (hash_value + 1) % size
used.add(hash_value)
result.append((item, to_base(alphabet, hash_value)))
return result | [
"def",
"hash_list_values",
"(",
"p_list",
",",
"p_key",
"=",
"lambda",
"i",
":",
"i",
")",
":",
"# pragma: no branch",
"def",
"to_base",
"(",
"p_alphabet",
",",
"p_value",
")",
":",
"\"\"\"\n Converts integer to text ID with characters from the given alphabet.\n\n Based on answer at\n https://stackoverflow.com/questions/1181919/python-base-36-encoding\n \"\"\"",
"result",
"=",
"''",
"while",
"p_value",
":",
"p_value",
",",
"i",
"=",
"divmod",
"(",
"p_value",
",",
"len",
"(",
"p_alphabet",
")",
")",
"result",
"=",
"p_alphabet",
"[",
"i",
"]",
"+",
"result",
"return",
"result",
"or",
"p_alphabet",
"[",
"0",
"]",
"result",
"=",
"[",
"]",
"used",
"=",
"set",
"(",
")",
"alphabet",
"=",
"config",
"(",
")",
".",
"identifier_alphabet",
"(",
")",
"try",
":",
"_",
",",
"size",
"=",
"_get_table_size",
"(",
"alphabet",
",",
"len",
"(",
"p_list",
")",
")",
"except",
"_TableSizeException",
":",
"alphabet",
"=",
"_DEFAULT_ALPHABET",
"_",
",",
"size",
"=",
"_get_table_size",
"(",
"alphabet",
",",
"len",
"(",
"p_list",
")",
")",
"for",
"item",
"in",
"p_list",
":",
"# obtain the to-be-hashed value",
"raw_value",
"=",
"p_key",
"(",
"item",
")",
"# hash",
"hasher",
"=",
"sha1",
"(",
")",
"hasher",
".",
"update",
"(",
"raw_value",
".",
"encode",
"(",
"'utf-8'",
")",
")",
"hash_value",
"=",
"int",
"(",
"hasher",
".",
"hexdigest",
"(",
")",
",",
"16",
")",
"%",
"size",
"# resolve possible collisions",
"while",
"hash_value",
"in",
"used",
":",
"hash_value",
"=",
"(",
"hash_value",
"+",
"1",
")",
"%",
"size",
"used",
".",
"add",
"(",
"hash_value",
")",
"result",
".",
"append",
"(",
"(",
"item",
",",
"to_base",
"(",
"alphabet",
",",
"hash_value",
")",
")",
")",
"return",
"result"
] | Calculates a unique value for each item in the list, these can be used as
identifiers.
The value is based on hashing an item using the p_key function.
Suitable for lists not larger than approx. 16K items.
Returns a tuple with the status and a list of tuples where each item is
combined with the ID. | [
"Calculates",
"a",
"unique",
"value",
"for",
"each",
"item",
"in",
"the",
"list",
"these",
"can",
"be",
"used",
"as",
"identifiers",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/HashListValues.py#L98-L150 | train |
bram85/topydo | topydo/lib/HashListValues.py | max_id_length | def max_id_length(p_num):
"""
Returns the length of the IDs used, given the number of items that are
assigned an ID. Used for padding in lists.
"""
try:
alphabet = config().identifier_alphabet()
length, _ = _get_table_size(alphabet, p_num)
except _TableSizeException:
length, _ = _get_table_size(_DEFAULT_ALPHABET, p_num)
return length | python | def max_id_length(p_num):
"""
Returns the length of the IDs used, given the number of items that are
assigned an ID. Used for padding in lists.
"""
try:
alphabet = config().identifier_alphabet()
length, _ = _get_table_size(alphabet, p_num)
except _TableSizeException:
length, _ = _get_table_size(_DEFAULT_ALPHABET, p_num)
return length | [
"def",
"max_id_length",
"(",
"p_num",
")",
":",
"try",
":",
"alphabet",
"=",
"config",
"(",
")",
".",
"identifier_alphabet",
"(",
")",
"length",
",",
"_",
"=",
"_get_table_size",
"(",
"alphabet",
",",
"p_num",
")",
"except",
"_TableSizeException",
":",
"length",
",",
"_",
"=",
"_get_table_size",
"(",
"_DEFAULT_ALPHABET",
",",
"p_num",
")",
"return",
"length"
] | Returns the length of the IDs used, given the number of items that are
assigned an ID. Used for padding in lists. | [
"Returns",
"the",
"length",
"of",
"the",
"IDs",
"used",
"given",
"the",
"number",
"of",
"items",
"that",
"are",
"assigned",
"an",
"ID",
".",
"Used",
"for",
"padding",
"in",
"lists",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/HashListValues.py#L152-L163 | train |
bram85/topydo | topydo/lib/prettyprinters/Colors.py | PrettyPrinterColorFilter.filter | def filter(self, p_todo_str, p_todo):
""" Applies the colors. """
if config().colors():
p_todo_str = TopydoString(p_todo_str, p_todo)
priority_color = config().priority_color(p_todo.priority())
colors = [
(r'\B@(\S*\w)', AbstractColor.CONTEXT),
(r'\B\+(\S*\w)', AbstractColor.PROJECT),
(r'\b\S+:[^/\s]\S*\b', AbstractColor.META),
(r'(^|\s)(\w+:){1}(//\S+)', AbstractColor.LINK),
]
# color by priority
p_todo_str.set_color(0, priority_color)
for pattern, color in colors:
for match in re.finditer(pattern, p_todo_str.data):
p_todo_str.set_color(match.start(), color)
p_todo_str.set_color(match.end(), priority_color)
p_todo_str.append('', AbstractColor.NEUTRAL)
return p_todo_str | python | def filter(self, p_todo_str, p_todo):
""" Applies the colors. """
if config().colors():
p_todo_str = TopydoString(p_todo_str, p_todo)
priority_color = config().priority_color(p_todo.priority())
colors = [
(r'\B@(\S*\w)', AbstractColor.CONTEXT),
(r'\B\+(\S*\w)', AbstractColor.PROJECT),
(r'\b\S+:[^/\s]\S*\b', AbstractColor.META),
(r'(^|\s)(\w+:){1}(//\S+)', AbstractColor.LINK),
]
# color by priority
p_todo_str.set_color(0, priority_color)
for pattern, color in colors:
for match in re.finditer(pattern, p_todo_str.data):
p_todo_str.set_color(match.start(), color)
p_todo_str.set_color(match.end(), priority_color)
p_todo_str.append('', AbstractColor.NEUTRAL)
return p_todo_str | [
"def",
"filter",
"(",
"self",
",",
"p_todo_str",
",",
"p_todo",
")",
":",
"if",
"config",
"(",
")",
".",
"colors",
"(",
")",
":",
"p_todo_str",
"=",
"TopydoString",
"(",
"p_todo_str",
",",
"p_todo",
")",
"priority_color",
"=",
"config",
"(",
")",
".",
"priority_color",
"(",
"p_todo",
".",
"priority",
"(",
")",
")",
"colors",
"=",
"[",
"(",
"r'\\B@(\\S*\\w)'",
",",
"AbstractColor",
".",
"CONTEXT",
")",
",",
"(",
"r'\\B\\+(\\S*\\w)'",
",",
"AbstractColor",
".",
"PROJECT",
")",
",",
"(",
"r'\\b\\S+:[^/\\s]\\S*\\b'",
",",
"AbstractColor",
".",
"META",
")",
",",
"(",
"r'(^|\\s)(\\w+:){1}(//\\S+)'",
",",
"AbstractColor",
".",
"LINK",
")",
",",
"]",
"# color by priority",
"p_todo_str",
".",
"set_color",
"(",
"0",
",",
"priority_color",
")",
"for",
"pattern",
",",
"color",
"in",
"colors",
":",
"for",
"match",
"in",
"re",
".",
"finditer",
"(",
"pattern",
",",
"p_todo_str",
".",
"data",
")",
":",
"p_todo_str",
".",
"set_color",
"(",
"match",
".",
"start",
"(",
")",
",",
"color",
")",
"p_todo_str",
".",
"set_color",
"(",
"match",
".",
"end",
"(",
")",
",",
"priority_color",
")",
"p_todo_str",
".",
"append",
"(",
"''",
",",
"AbstractColor",
".",
"NEUTRAL",
")",
"return",
"p_todo_str"
] | Applies the colors. | [
"Applies",
"the",
"colors",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/prettyprinters/Colors.py#L34-L58 | train |
bram85/topydo | topydo/lib/Filter.py | get_filter_list | def get_filter_list(p_expression):
"""
Returns a list of GrepFilters, OrdinalTagFilters or NegationFilters based
on the given filter expression.
The filter expression is a list of strings.
"""
result = []
for arg in p_expression:
# when a word starts with -, it should be negated
is_negated = len(arg) > 1 and arg[0] == '-'
arg = arg[1:] if is_negated else arg
argfilter = None
for match, _filter in MATCHES:
if re.match(match, arg):
argfilter = _filter(arg)
break
if not argfilter:
argfilter = GrepFilter(arg)
if is_negated:
argfilter = NegationFilter(argfilter)
result.append(argfilter)
return result | python | def get_filter_list(p_expression):
"""
Returns a list of GrepFilters, OrdinalTagFilters or NegationFilters based
on the given filter expression.
The filter expression is a list of strings.
"""
result = []
for arg in p_expression:
# when a word starts with -, it should be negated
is_negated = len(arg) > 1 and arg[0] == '-'
arg = arg[1:] if is_negated else arg
argfilter = None
for match, _filter in MATCHES:
if re.match(match, arg):
argfilter = _filter(arg)
break
if not argfilter:
argfilter = GrepFilter(arg)
if is_negated:
argfilter = NegationFilter(argfilter)
result.append(argfilter)
return result | [
"def",
"get_filter_list",
"(",
"p_expression",
")",
":",
"result",
"=",
"[",
"]",
"for",
"arg",
"in",
"p_expression",
":",
"# when a word starts with -, it should be negated",
"is_negated",
"=",
"len",
"(",
"arg",
")",
">",
"1",
"and",
"arg",
"[",
"0",
"]",
"==",
"'-'",
"arg",
"=",
"arg",
"[",
"1",
":",
"]",
"if",
"is_negated",
"else",
"arg",
"argfilter",
"=",
"None",
"for",
"match",
",",
"_filter",
"in",
"MATCHES",
":",
"if",
"re",
".",
"match",
"(",
"match",
",",
"arg",
")",
":",
"argfilter",
"=",
"_filter",
"(",
"arg",
")",
"break",
"if",
"not",
"argfilter",
":",
"argfilter",
"=",
"GrepFilter",
"(",
"arg",
")",
"if",
"is_negated",
":",
"argfilter",
"=",
"NegationFilter",
"(",
"argfilter",
")",
"result",
".",
"append",
"(",
"argfilter",
")",
"return",
"result"
] | Returns a list of GrepFilters, OrdinalTagFilters or NegationFilters based
on the given filter expression.
The filter expression is a list of strings. | [
"Returns",
"a",
"list",
"of",
"GrepFilters",
"OrdinalTagFilters",
"or",
"NegationFilters",
"based",
"on",
"the",
"given",
"filter",
"expression",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L377-L404 | train |
bram85/topydo | topydo/lib/Filter.py | DependencyFilter.match | def match(self, p_todo):
"""
Returns True when there are no children that are uncompleted yet.
"""
children = self.todolist.children(p_todo)
uncompleted = [todo for todo in children if not todo.is_completed()]
return not uncompleted | python | def match(self, p_todo):
"""
Returns True when there are no children that are uncompleted yet.
"""
children = self.todolist.children(p_todo)
uncompleted = [todo for todo in children if not todo.is_completed()]
return not uncompleted | [
"def",
"match",
"(",
"self",
",",
"p_todo",
")",
":",
"children",
"=",
"self",
".",
"todolist",
".",
"children",
"(",
"p_todo",
")",
"uncompleted",
"=",
"[",
"todo",
"for",
"todo",
"in",
"children",
"if",
"not",
"todo",
".",
"is_completed",
"(",
")",
"]",
"return",
"not",
"uncompleted"
] | Returns True when there are no children that are uncompleted yet. | [
"Returns",
"True",
"when",
"there",
"are",
"no",
"children",
"that",
"are",
"uncompleted",
"yet",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L135-L142 | train |
bram85/topydo | topydo/lib/Filter.py | InstanceFilter.match | def match(self, p_todo):
"""
Returns True when p_todo appears in the list of given todos.
"""
try:
self.todos.index(p_todo)
return True
except ValueError:
return False | python | def match(self, p_todo):
"""
Returns True when p_todo appears in the list of given todos.
"""
try:
self.todos.index(p_todo)
return True
except ValueError:
return False | [
"def",
"match",
"(",
"self",
",",
"p_todo",
")",
":",
"try",
":",
"self",
".",
"todos",
".",
"index",
"(",
"p_todo",
")",
"return",
"True",
"except",
"ValueError",
":",
"return",
"False"
] | Returns True when p_todo appears in the list of given todos. | [
"Returns",
"True",
"when",
"p_todo",
"appears",
"in",
"the",
"list",
"of",
"given",
"todos",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L166-L174 | train |
bram85/topydo | topydo/lib/Filter.py | HiddenTagFilter.match | def match(self, p_todo):
"""
Returns True when p_todo doesn't have a tag to mark it as hidden.
"""
for my_tag in config().hidden_item_tags():
my_values = p_todo.tag_values(my_tag)
for my_value in my_values:
if not my_value in (0, '0', False, 'False'):
return False
return True | python | def match(self, p_todo):
"""
Returns True when p_todo doesn't have a tag to mark it as hidden.
"""
for my_tag in config().hidden_item_tags():
my_values = p_todo.tag_values(my_tag)
for my_value in my_values:
if not my_value in (0, '0', False, 'False'):
return False
return True | [
"def",
"match",
"(",
"self",
",",
"p_todo",
")",
":",
"for",
"my_tag",
"in",
"config",
"(",
")",
".",
"hidden_item_tags",
"(",
")",
":",
"my_values",
"=",
"p_todo",
".",
"tag_values",
"(",
"my_tag",
")",
"for",
"my_value",
"in",
"my_values",
":",
"if",
"not",
"my_value",
"in",
"(",
"0",
",",
"'0'",
",",
"False",
",",
"'False'",
")",
":",
"return",
"False",
"return",
"True"
] | Returns True when p_todo doesn't have a tag to mark it as hidden. | [
"Returns",
"True",
"when",
"p_todo",
"doesn",
"t",
"have",
"a",
"tag",
"to",
"mark",
"it",
"as",
"hidden",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L186-L196 | train |
bram85/topydo | topydo/lib/Filter.py | OrdinalFilter.compare_operands | def compare_operands(self, p_operand1, p_operand2):
"""
Returns True if conditional constructed from both operands and
self.operator is valid. Returns False otherwise.
"""
if self.operator == '<':
return p_operand1 < p_operand2
elif self.operator == '<=':
return p_operand1 <= p_operand2
elif self.operator == '=':
return p_operand1 == p_operand2
elif self.operator == '>=':
return p_operand1 >= p_operand2
elif self.operator == '>':
return p_operand1 > p_operand2
elif self.operator == '!':
return p_operand1 != p_operand2
return False | python | def compare_operands(self, p_operand1, p_operand2):
"""
Returns True if conditional constructed from both operands and
self.operator is valid. Returns False otherwise.
"""
if self.operator == '<':
return p_operand1 < p_operand2
elif self.operator == '<=':
return p_operand1 <= p_operand2
elif self.operator == '=':
return p_operand1 == p_operand2
elif self.operator == '>=':
return p_operand1 >= p_operand2
elif self.operator == '>':
return p_operand1 > p_operand2
elif self.operator == '!':
return p_operand1 != p_operand2
return False | [
"def",
"compare_operands",
"(",
"self",
",",
"p_operand1",
",",
"p_operand2",
")",
":",
"if",
"self",
".",
"operator",
"==",
"'<'",
":",
"return",
"p_operand1",
"<",
"p_operand2",
"elif",
"self",
".",
"operator",
"==",
"'<='",
":",
"return",
"p_operand1",
"<=",
"p_operand2",
"elif",
"self",
".",
"operator",
"==",
"'='",
":",
"return",
"p_operand1",
"==",
"p_operand2",
"elif",
"self",
".",
"operator",
"==",
"'>='",
":",
"return",
"p_operand1",
">=",
"p_operand2",
"elif",
"self",
".",
"operator",
"==",
"'>'",
":",
"return",
"p_operand1",
">",
"p_operand2",
"elif",
"self",
".",
"operator",
"==",
"'!'",
":",
"return",
"p_operand1",
"!=",
"p_operand2",
"return",
"False"
] | Returns True if conditional constructed from both operands and
self.operator is valid. Returns False otherwise. | [
"Returns",
"True",
"if",
"conditional",
"constructed",
"from",
"both",
"operands",
"and",
"self",
".",
"operator",
"is",
"valid",
".",
"Returns",
"False",
"otherwise",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L232-L250 | train |
bram85/topydo | topydo/lib/Filter.py | PriorityFilter.match | def match(self, p_todo):
"""
Performs a match on a priority in the todo.
It gets priority from p_todo and compares it with user-entered
expression based on the given operator (default ==). It does that however
in reversed order to obtain more intuitive result. Example: (>B) will
match todos with priority (A).
Items without priority are designated with corresponding operand set to
'ZZ', because python doesn't allow NoneType() and str() comparisons.
"""
operand1 = self.value
operand2 = p_todo.priority() or 'ZZ'
return self.compare_operands(operand1, operand2) | python | def match(self, p_todo):
"""
Performs a match on a priority in the todo.
It gets priority from p_todo and compares it with user-entered
expression based on the given operator (default ==). It does that however
in reversed order to obtain more intuitive result. Example: (>B) will
match todos with priority (A).
Items without priority are designated with corresponding operand set to
'ZZ', because python doesn't allow NoneType() and str() comparisons.
"""
operand1 = self.value
operand2 = p_todo.priority() or 'ZZ'
return self.compare_operands(operand1, operand2) | [
"def",
"match",
"(",
"self",
",",
"p_todo",
")",
":",
"operand1",
"=",
"self",
".",
"value",
"operand2",
"=",
"p_todo",
".",
"priority",
"(",
")",
"or",
"'ZZ'",
"return",
"self",
".",
"compare_operands",
"(",
"operand1",
",",
"operand2",
")"
] | Performs a match on a priority in the todo.
It gets priority from p_todo and compares it with user-entered
expression based on the given operator (default ==). It does that however
in reversed order to obtain more intuitive result. Example: (>B) will
match todos with priority (A).
Items without priority are designated with corresponding operand set to
'ZZ', because python doesn't allow NoneType() and str() comparisons. | [
"Performs",
"a",
"match",
"on",
"a",
"priority",
"in",
"the",
"todo",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Filter.py#L354-L368 | train |
bram85/topydo | topydo/ui/CompleterBase.py | date_suggestions | def date_suggestions():
"""
Returns a list of relative date that is presented to the user as auto
complete suggestions.
"""
# don't use strftime, prevent locales to kick in
days_of_week = {
0: "Monday",
1: "Tuesday",
2: "Wednesday",
3: "Thursday",
4: "Friday",
5: "Saturday",
6: "Sunday"
}
dates = [
'today',
'tomorrow',
]
# show days of week up to next week
dow = datetime.date.today().weekday()
for i in range(dow + 2 % 7, dow + 7):
dates.append(days_of_week[i % 7])
# and some more relative days starting from next week
dates += ["1w", "2w", "1m", "2m", "3m", "1y"]
return dates | python | def date_suggestions():
"""
Returns a list of relative date that is presented to the user as auto
complete suggestions.
"""
# don't use strftime, prevent locales to kick in
days_of_week = {
0: "Monday",
1: "Tuesday",
2: "Wednesday",
3: "Thursday",
4: "Friday",
5: "Saturday",
6: "Sunday"
}
dates = [
'today',
'tomorrow',
]
# show days of week up to next week
dow = datetime.date.today().weekday()
for i in range(dow + 2 % 7, dow + 7):
dates.append(days_of_week[i % 7])
# and some more relative days starting from next week
dates += ["1w", "2w", "1m", "2m", "3m", "1y"]
return dates | [
"def",
"date_suggestions",
"(",
")",
":",
"# don't use strftime, prevent locales to kick in",
"days_of_week",
"=",
"{",
"0",
":",
"\"Monday\"",
",",
"1",
":",
"\"Tuesday\"",
",",
"2",
":",
"\"Wednesday\"",
",",
"3",
":",
"\"Thursday\"",
",",
"4",
":",
"\"Friday\"",
",",
"5",
":",
"\"Saturday\"",
",",
"6",
":",
"\"Sunday\"",
"}",
"dates",
"=",
"[",
"'today'",
",",
"'tomorrow'",
",",
"]",
"# show days of week up to next week",
"dow",
"=",
"datetime",
".",
"date",
".",
"today",
"(",
")",
".",
"weekday",
"(",
")",
"for",
"i",
"in",
"range",
"(",
"dow",
"+",
"2",
"%",
"7",
",",
"dow",
"+",
"7",
")",
":",
"dates",
".",
"append",
"(",
"days_of_week",
"[",
"i",
"%",
"7",
"]",
")",
"# and some more relative days starting from next week",
"dates",
"+=",
"[",
"\"1w\"",
",",
"\"2w\"",
",",
"\"1m\"",
",",
"\"2m\"",
",",
"\"3m\"",
",",
"\"1y\"",
"]",
"return",
"dates"
] | Returns a list of relative date that is presented to the user as auto
complete suggestions. | [
"Returns",
"a",
"list",
"of",
"relative",
"date",
"that",
"is",
"presented",
"to",
"the",
"user",
"as",
"auto",
"complete",
"suggestions",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CompleterBase.py#L32-L61 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | write | def write(p_file, p_string):
"""
Write p_string to file p_file, trailed by a newline character.
ANSI codes are removed when the file is not a TTY (and colors are
automatically determined).
"""
if not config().colors(p_file.isatty()):
p_string = escape_ansi(p_string)
if p_string:
p_file.write(p_string + "\n") | python | def write(p_file, p_string):
"""
Write p_string to file p_file, trailed by a newline character.
ANSI codes are removed when the file is not a TTY (and colors are
automatically determined).
"""
if not config().colors(p_file.isatty()):
p_string = escape_ansi(p_string)
if p_string:
p_file.write(p_string + "\n") | [
"def",
"write",
"(",
"p_file",
",",
"p_string",
")",
":",
"if",
"not",
"config",
"(",
")",
".",
"colors",
"(",
"p_file",
".",
"isatty",
"(",
")",
")",
":",
"p_string",
"=",
"escape_ansi",
"(",
"p_string",
")",
"if",
"p_string",
":",
"p_file",
".",
"write",
"(",
"p_string",
"+",
"\"\\n\"",
")"
] | Write p_string to file p_file, trailed by a newline character.
ANSI codes are removed when the file is not a TTY (and colors are
automatically determined). | [
"Write",
"p_string",
"to",
"file",
"p_file",
"trailed",
"by",
"a",
"newline",
"character",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L72-L83 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | lookup_color | def lookup_color(p_color):
"""
Converts an AbstractColor to a normal Color. Returns the Color itself
when a normal color is passed.
"""
if not lookup_color.colors:
lookup_color.colors[AbstractColor.NEUTRAL] = Color('NEUTRAL')
lookup_color.colors[AbstractColor.PROJECT] = config().project_color()
lookup_color.colors[AbstractColor.CONTEXT] = config().context_color()
lookup_color.colors[AbstractColor.META] = config().metadata_color()
lookup_color.colors[AbstractColor.LINK] = config().link_color()
try:
return lookup_color.colors[p_color]
except KeyError:
return p_color | python | def lookup_color(p_color):
"""
Converts an AbstractColor to a normal Color. Returns the Color itself
when a normal color is passed.
"""
if not lookup_color.colors:
lookup_color.colors[AbstractColor.NEUTRAL] = Color('NEUTRAL')
lookup_color.colors[AbstractColor.PROJECT] = config().project_color()
lookup_color.colors[AbstractColor.CONTEXT] = config().context_color()
lookup_color.colors[AbstractColor.META] = config().metadata_color()
lookup_color.colors[AbstractColor.LINK] = config().link_color()
try:
return lookup_color.colors[p_color]
except KeyError:
return p_color | [
"def",
"lookup_color",
"(",
"p_color",
")",
":",
"if",
"not",
"lookup_color",
".",
"colors",
":",
"lookup_color",
".",
"colors",
"[",
"AbstractColor",
".",
"NEUTRAL",
"]",
"=",
"Color",
"(",
"'NEUTRAL'",
")",
"lookup_color",
".",
"colors",
"[",
"AbstractColor",
".",
"PROJECT",
"]",
"=",
"config",
"(",
")",
".",
"project_color",
"(",
")",
"lookup_color",
".",
"colors",
"[",
"AbstractColor",
".",
"CONTEXT",
"]",
"=",
"config",
"(",
")",
".",
"context_color",
"(",
")",
"lookup_color",
".",
"colors",
"[",
"AbstractColor",
".",
"META",
"]",
"=",
"config",
"(",
")",
".",
"metadata_color",
"(",
")",
"lookup_color",
".",
"colors",
"[",
"AbstractColor",
".",
"LINK",
"]",
"=",
"config",
"(",
")",
".",
"link_color",
"(",
")",
"try",
":",
"return",
"lookup_color",
".",
"colors",
"[",
"p_color",
"]",
"except",
"KeyError",
":",
"return",
"p_color"
] | Converts an AbstractColor to a normal Color. Returns the Color itself
when a normal color is passed. | [
"Converts",
"an",
"AbstractColor",
"to",
"a",
"normal",
"Color",
".",
"Returns",
"the",
"Color",
"itself",
"when",
"a",
"normal",
"color",
"is",
"passed",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L86-L101 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | insert_ansi | def insert_ansi(p_string):
""" Returns a string with color information at the right positions. """
result = p_string.data
for pos, color in sorted(p_string.colors.items(), reverse=True):
color = lookup_color(color)
result = result[:pos] + color.as_ansi() + result[pos:]
return result | python | def insert_ansi(p_string):
""" Returns a string with color information at the right positions. """
result = p_string.data
for pos, color in sorted(p_string.colors.items(), reverse=True):
color = lookup_color(color)
result = result[:pos] + color.as_ansi() + result[pos:]
return result | [
"def",
"insert_ansi",
"(",
"p_string",
")",
":",
"result",
"=",
"p_string",
".",
"data",
"for",
"pos",
",",
"color",
"in",
"sorted",
"(",
"p_string",
".",
"colors",
".",
"items",
"(",
")",
",",
"reverse",
"=",
"True",
")",
":",
"color",
"=",
"lookup_color",
"(",
"color",
")",
"result",
"=",
"result",
"[",
":",
"pos",
"]",
"+",
"color",
".",
"as_ansi",
"(",
")",
"+",
"result",
"[",
"pos",
":",
"]",
"return",
"result"
] | Returns a string with color information at the right positions. | [
"Returns",
"a",
"string",
"with",
"color",
"information",
"at",
"the",
"right",
"positions",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L105-L114 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | version | def version():
""" Print the current version and exit. """
from topydo.lib.Version import VERSION, LICENSE
print("topydo {}\n".format(VERSION))
print(LICENSE)
sys.exit(0) | python | def version():
""" Print the current version and exit. """
from topydo.lib.Version import VERSION, LICENSE
print("topydo {}\n".format(VERSION))
print(LICENSE)
sys.exit(0) | [
"def",
"version",
"(",
")",
":",
"from",
"topydo",
".",
"lib",
".",
"Version",
"import",
"VERSION",
",",
"LICENSE",
"print",
"(",
"\"topydo {}\\n\"",
".",
"format",
"(",
"VERSION",
")",
")",
"print",
"(",
"LICENSE",
")",
"sys",
".",
"exit",
"(",
"0",
")"
] | Print the current version and exit. | [
"Print",
"the",
"current",
"version",
"and",
"exit",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L130-L135 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | CLIApplicationBase._archive | def _archive(self):
"""
Performs an archive action on the todolist.
This means that all completed tasks are moved to the archive file
(defaults to done.txt).
"""
archive, archive_file = _retrieve_archive()
if self.backup:
self.backup.add_archive(archive)
if archive:
from topydo.commands.ArchiveCommand import ArchiveCommand
command = ArchiveCommand(self.todolist, archive)
command.execute()
if archive.dirty:
archive_file.write(archive.print_todos()) | python | def _archive(self):
"""
Performs an archive action on the todolist.
This means that all completed tasks are moved to the archive file
(defaults to done.txt).
"""
archive, archive_file = _retrieve_archive()
if self.backup:
self.backup.add_archive(archive)
if archive:
from topydo.commands.ArchiveCommand import ArchiveCommand
command = ArchiveCommand(self.todolist, archive)
command.execute()
if archive.dirty:
archive_file.write(archive.print_todos()) | [
"def",
"_archive",
"(",
"self",
")",
":",
"archive",
",",
"archive_file",
"=",
"_retrieve_archive",
"(",
")",
"if",
"self",
".",
"backup",
":",
"self",
".",
"backup",
".",
"add_archive",
"(",
"archive",
")",
"if",
"archive",
":",
"from",
"topydo",
".",
"commands",
".",
"ArchiveCommand",
"import",
"ArchiveCommand",
"command",
"=",
"ArchiveCommand",
"(",
"self",
".",
"todolist",
",",
"archive",
")",
"command",
".",
"execute",
"(",
")",
"if",
"archive",
".",
"dirty",
":",
"archive_file",
".",
"write",
"(",
"archive",
".",
"print_todos",
"(",
")",
")"
] | Performs an archive action on the todolist.
This means that all completed tasks are moved to the archive file
(defaults to done.txt). | [
"Performs",
"an",
"archive",
"action",
"on",
"the",
"todolist",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L221-L239 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | CLIApplicationBase.is_read_only | def is_read_only(p_command):
""" Returns True when the given command class is read-only. """
read_only_commands = tuple(cmd for cmd
in ('revert', ) + READ_ONLY_COMMANDS)
return p_command.name() in read_only_commands | python | def is_read_only(p_command):
""" Returns True when the given command class is read-only. """
read_only_commands = tuple(cmd for cmd
in ('revert', ) + READ_ONLY_COMMANDS)
return p_command.name() in read_only_commands | [
"def",
"is_read_only",
"(",
"p_command",
")",
":",
"read_only_commands",
"=",
"tuple",
"(",
"cmd",
"for",
"cmd",
"in",
"(",
"'revert'",
",",
")",
"+",
"READ_ONLY_COMMANDS",
")",
"return",
"p_command",
".",
"name",
"(",
")",
"in",
"read_only_commands"
] | Returns True when the given command class is read-only. | [
"Returns",
"True",
"when",
"the",
"given",
"command",
"class",
"is",
"read",
"-",
"only",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L242-L246 | train |
bram85/topydo | topydo/ui/CLIApplicationBase.py | CLIApplicationBase._post_execute | def _post_execute(self):
"""
Should be called when executing the user requested command has been
completed. It will do some maintenance and write out the final result
to the todo.txt file.
"""
if self.todolist.dirty:
# do not archive when the value of the filename is an empty string
# (i.e. explicitly left empty in the configuration
if self.do_archive and config().archive():
self._archive()
elif config().archive() and self.backup:
archive = _retrieve_archive()[0]
self.backup.add_archive(archive)
self._post_archive_action()
if config().keep_sorted():
from topydo.commands.SortCommand import SortCommand
self._execute(SortCommand, [])
if self.backup:
self.backup.save(self.todolist)
self.todofile.write(self.todolist.print_todos())
self.todolist.dirty = False
self.backup = None | python | def _post_execute(self):
"""
Should be called when executing the user requested command has been
completed. It will do some maintenance and write out the final result
to the todo.txt file.
"""
if self.todolist.dirty:
# do not archive when the value of the filename is an empty string
# (i.e. explicitly left empty in the configuration
if self.do_archive and config().archive():
self._archive()
elif config().archive() and self.backup:
archive = _retrieve_archive()[0]
self.backup.add_archive(archive)
self._post_archive_action()
if config().keep_sorted():
from topydo.commands.SortCommand import SortCommand
self._execute(SortCommand, [])
if self.backup:
self.backup.save(self.todolist)
self.todofile.write(self.todolist.print_todos())
self.todolist.dirty = False
self.backup = None | [
"def",
"_post_execute",
"(",
"self",
")",
":",
"if",
"self",
".",
"todolist",
".",
"dirty",
":",
"# do not archive when the value of the filename is an empty string",
"# (i.e. explicitly left empty in the configuration",
"if",
"self",
".",
"do_archive",
"and",
"config",
"(",
")",
".",
"archive",
"(",
")",
":",
"self",
".",
"_archive",
"(",
")",
"elif",
"config",
"(",
")",
".",
"archive",
"(",
")",
"and",
"self",
".",
"backup",
":",
"archive",
"=",
"_retrieve_archive",
"(",
")",
"[",
"0",
"]",
"self",
".",
"backup",
".",
"add_archive",
"(",
"archive",
")",
"self",
".",
"_post_archive_action",
"(",
")",
"if",
"config",
"(",
")",
".",
"keep_sorted",
"(",
")",
":",
"from",
"topydo",
".",
"commands",
".",
"SortCommand",
"import",
"SortCommand",
"self",
".",
"_execute",
"(",
"SortCommand",
",",
"[",
"]",
")",
"if",
"self",
".",
"backup",
":",
"self",
".",
"backup",
".",
"save",
"(",
"self",
".",
"todolist",
")",
"self",
".",
"todofile",
".",
"write",
"(",
"self",
".",
"todolist",
".",
"print_todos",
"(",
")",
")",
"self",
".",
"todolist",
".",
"dirty",
"=",
"False",
"self",
".",
"backup",
"=",
"None"
] | Should be called when executing the user requested command has been
completed. It will do some maintenance and write out the final result
to the todo.txt file. | [
"Should",
"be",
"called",
"when",
"executing",
"the",
"user",
"requested",
"command",
"has",
"been",
"completed",
".",
"It",
"will",
"do",
"some",
"maintenance",
"and",
"write",
"out",
"the",
"final",
"result",
"to",
"the",
"todo",
".",
"txt",
"file",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/ui/CLIApplicationBase.py#L277-L305 | train |
bram85/topydo | topydo/lib/Todo.py | Todo.get_date | def get_date(self, p_tag):
""" Given a date tag, return a date object. """
string = self.tag_value(p_tag)
result = None
try:
result = date_string_to_date(string) if string else None
except ValueError:
pass
return result | python | def get_date(self, p_tag):
""" Given a date tag, return a date object. """
string = self.tag_value(p_tag)
result = None
try:
result = date_string_to_date(string) if string else None
except ValueError:
pass
return result | [
"def",
"get_date",
"(",
"self",
",",
"p_tag",
")",
":",
"string",
"=",
"self",
".",
"tag_value",
"(",
"p_tag",
")",
"result",
"=",
"None",
"try",
":",
"result",
"=",
"date_string_to_date",
"(",
"string",
")",
"if",
"string",
"else",
"None",
"except",
"ValueError",
":",
"pass",
"return",
"result"
] | Given a date tag, return a date object. | [
"Given",
"a",
"date",
"tag",
"return",
"a",
"date",
"object",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Todo.py#L38-L48 | train |
bram85/topydo | topydo/lib/Todo.py | Todo.is_active | def is_active(self):
"""
Returns True when the start date is today or in the past and the
task has not yet been completed.
"""
start = self.start_date()
return not self.is_completed() and (not start or start <= date.today()) | python | def is_active(self):
"""
Returns True when the start date is today or in the past and the
task has not yet been completed.
"""
start = self.start_date()
return not self.is_completed() and (not start or start <= date.today()) | [
"def",
"is_active",
"(",
"self",
")",
":",
"start",
"=",
"self",
".",
"start_date",
"(",
")",
"return",
"not",
"self",
".",
"is_completed",
"(",
")",
"and",
"(",
"not",
"start",
"or",
"start",
"<=",
"date",
".",
"today",
"(",
")",
")"
] | Returns True when the start date is today or in the past and the
task has not yet been completed. | [
"Returns",
"True",
"when",
"the",
"start",
"date",
"is",
"today",
"or",
"in",
"the",
"past",
"and",
"the",
"task",
"has",
"not",
"yet",
"been",
"completed",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Todo.py#L58-L64 | train |
bram85/topydo | topydo/lib/Todo.py | Todo.days_till_due | def days_till_due(self):
"""
Returns the number of days till the due date. Returns a negative number
of days when the due date is in the past.
Returns 0 when the task has no due date.
"""
due = self.due_date()
if due:
diff = due - date.today()
return diff.days
return 0 | python | def days_till_due(self):
"""
Returns the number of days till the due date. Returns a negative number
of days when the due date is in the past.
Returns 0 when the task has no due date.
"""
due = self.due_date()
if due:
diff = due - date.today()
return diff.days
return 0 | [
"def",
"days_till_due",
"(",
"self",
")",
":",
"due",
"=",
"self",
".",
"due_date",
"(",
")",
"if",
"due",
":",
"diff",
"=",
"due",
"-",
"date",
".",
"today",
"(",
")",
"return",
"diff",
".",
"days",
"return",
"0"
] | Returns the number of days till the due date. Returns a negative number
of days when the due date is in the past.
Returns 0 when the task has no due date. | [
"Returns",
"the",
"number",
"of",
"days",
"till",
"the",
"due",
"date",
".",
"Returns",
"a",
"negative",
"number",
"of",
"days",
"when",
"the",
"due",
"date",
"is",
"in",
"the",
"past",
".",
"Returns",
"0",
"when",
"the",
"task",
"has",
"no",
"due",
"date",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/lib/Todo.py#L73-L83 | train |
bram85/topydo | topydo/commands/DepCommand.py | DepCommand._handle_ls | def _handle_ls(self):
""" Handles the ls subsubcommand. """
try:
arg1 = self.argument(1)
arg2 = self.argument(2)
todos = []
if arg2 == 'to' or arg1 == 'before':
# dep ls 1 to OR dep ls before 1
number = arg1 if arg2 == 'to' else arg2
todo = self.todolist.todo(number)
todos = self.todolist.children(todo)
elif arg1 in {'to', 'after'}:
# dep ls to 1 OR dep ls after 1
number = arg2
todo = self.todolist.todo(number)
todos = self.todolist.parents(todo)
else:
raise InvalidCommandArgument
sorter = Sorter(config().sort_string())
instance_filter = Filter.InstanceFilter(todos)
view = View(sorter, [instance_filter], self.todolist)
self.out(self.printer.print_list(view.todos))
except InvalidTodoException:
self.error("Invalid todo number given.")
except InvalidCommandArgument:
self.error(self.usage()) | python | def _handle_ls(self):
""" Handles the ls subsubcommand. """
try:
arg1 = self.argument(1)
arg2 = self.argument(2)
todos = []
if arg2 == 'to' or arg1 == 'before':
# dep ls 1 to OR dep ls before 1
number = arg1 if arg2 == 'to' else arg2
todo = self.todolist.todo(number)
todos = self.todolist.children(todo)
elif arg1 in {'to', 'after'}:
# dep ls to 1 OR dep ls after 1
number = arg2
todo = self.todolist.todo(number)
todos = self.todolist.parents(todo)
else:
raise InvalidCommandArgument
sorter = Sorter(config().sort_string())
instance_filter = Filter.InstanceFilter(todos)
view = View(sorter, [instance_filter], self.todolist)
self.out(self.printer.print_list(view.todos))
except InvalidTodoException:
self.error("Invalid todo number given.")
except InvalidCommandArgument:
self.error(self.usage()) | [
"def",
"_handle_ls",
"(",
"self",
")",
":",
"try",
":",
"arg1",
"=",
"self",
".",
"argument",
"(",
"1",
")",
"arg2",
"=",
"self",
".",
"argument",
"(",
"2",
")",
"todos",
"=",
"[",
"]",
"if",
"arg2",
"==",
"'to'",
"or",
"arg1",
"==",
"'before'",
":",
"# dep ls 1 to OR dep ls before 1",
"number",
"=",
"arg1",
"if",
"arg2",
"==",
"'to'",
"else",
"arg2",
"todo",
"=",
"self",
".",
"todolist",
".",
"todo",
"(",
"number",
")",
"todos",
"=",
"self",
".",
"todolist",
".",
"children",
"(",
"todo",
")",
"elif",
"arg1",
"in",
"{",
"'to'",
",",
"'after'",
"}",
":",
"# dep ls to 1 OR dep ls after 1",
"number",
"=",
"arg2",
"todo",
"=",
"self",
".",
"todolist",
".",
"todo",
"(",
"number",
")",
"todos",
"=",
"self",
".",
"todolist",
".",
"parents",
"(",
"todo",
")",
"else",
":",
"raise",
"InvalidCommandArgument",
"sorter",
"=",
"Sorter",
"(",
"config",
"(",
")",
".",
"sort_string",
"(",
")",
")",
"instance_filter",
"=",
"Filter",
".",
"InstanceFilter",
"(",
"todos",
")",
"view",
"=",
"View",
"(",
"sorter",
",",
"[",
"instance_filter",
"]",
",",
"self",
".",
"todolist",
")",
"self",
".",
"out",
"(",
"self",
".",
"printer",
".",
"print_list",
"(",
"view",
".",
"todos",
")",
")",
"except",
"InvalidTodoException",
":",
"self",
".",
"error",
"(",
"\"Invalid todo number given.\"",
")",
"except",
"InvalidCommandArgument",
":",
"self",
".",
"error",
"(",
"self",
".",
"usage",
"(",
")",
")"
] | Handles the ls subsubcommand. | [
"Handles",
"the",
"ls",
"subsubcommand",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/commands/DepCommand.py#L104-L131 | train |
bram85/topydo | topydo/commands/DepCommand.py | DepCommand._handle_dot | def _handle_dot(self):
""" Handles the dot subsubcommand. """
self.printer = DotPrinter(self.todolist)
try:
arg = self.argument(1)
todo = self.todolist.todo(arg)
arg = self.argument(1)
todos = set([self.todolist.todo(arg)])
todos |= set(self.todolist.children(todo))
todos |= set(self.todolist.parents(todo))
todos = sorted(todos, key=lambda t: t.text())
self.out(self.printer.print_list(todos))
except InvalidTodoException:
self.error("Invalid todo number given.")
except InvalidCommandArgument:
self.error(self.usage()) | python | def _handle_dot(self):
""" Handles the dot subsubcommand. """
self.printer = DotPrinter(self.todolist)
try:
arg = self.argument(1)
todo = self.todolist.todo(arg)
arg = self.argument(1)
todos = set([self.todolist.todo(arg)])
todos |= set(self.todolist.children(todo))
todos |= set(self.todolist.parents(todo))
todos = sorted(todos, key=lambda t: t.text())
self.out(self.printer.print_list(todos))
except InvalidTodoException:
self.error("Invalid todo number given.")
except InvalidCommandArgument:
self.error(self.usage()) | [
"def",
"_handle_dot",
"(",
"self",
")",
":",
"self",
".",
"printer",
"=",
"DotPrinter",
"(",
"self",
".",
"todolist",
")",
"try",
":",
"arg",
"=",
"self",
".",
"argument",
"(",
"1",
")",
"todo",
"=",
"self",
".",
"todolist",
".",
"todo",
"(",
"arg",
")",
"arg",
"=",
"self",
".",
"argument",
"(",
"1",
")",
"todos",
"=",
"set",
"(",
"[",
"self",
".",
"todolist",
".",
"todo",
"(",
"arg",
")",
"]",
")",
"todos",
"|=",
"set",
"(",
"self",
".",
"todolist",
".",
"children",
"(",
"todo",
")",
")",
"todos",
"|=",
"set",
"(",
"self",
".",
"todolist",
".",
"parents",
"(",
"todo",
")",
")",
"todos",
"=",
"sorted",
"(",
"todos",
",",
"key",
"=",
"lambda",
"t",
":",
"t",
".",
"text",
"(",
")",
")",
"self",
".",
"out",
"(",
"self",
".",
"printer",
".",
"print_list",
"(",
"todos",
")",
")",
"except",
"InvalidTodoException",
":",
"self",
".",
"error",
"(",
"\"Invalid todo number given.\"",
")",
"except",
"InvalidCommandArgument",
":",
"self",
".",
"error",
"(",
"self",
".",
"usage",
"(",
")",
")"
] | Handles the dot subsubcommand. | [
"Handles",
"the",
"dot",
"subsubcommand",
"."
] | b59fcfca5361869a6b78d4c9808c7c6cd0a18b58 | https://github.com/bram85/topydo/blob/b59fcfca5361869a6b78d4c9808c7c6cd0a18b58/topydo/commands/DepCommand.py#L133-L150 | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.