repository_name
stringlengths 5
67
| func_path_in_repository
stringlengths 4
234
| func_name
stringlengths 0
314
| whole_func_string
stringlengths 52
3.87M
| language
stringclasses 6
values | func_code_string
stringlengths 52
3.87M
| func_code_tokens
sequencelengths 15
672k
| func_documentation_string
stringlengths 1
47.2k
| func_documentation_tokens
sequencelengths 1
3.92k
| split_name
stringclasses 1
value | func_code_url
stringlengths 85
339
|
|---|---|---|---|---|---|---|---|---|---|---|
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneMatcher.add | def add(self, pattern: Pattern, label=None) -> None:
"""Add a new pattern to the matcher.
The optional label defaults to the pattern itself and is yielded during matching. The same pattern can be
added with different labels which means that every match for the pattern will result in every associated label
being yielded with that match individually.
Equivalent patterns with the same label are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern:
The pattern to add.
label:
An optional label for the pattern. Defaults to the pattern itself.
"""
if label is None:
label = pattern
for i, (p, l, _) in enumerate(self.patterns):
if pattern == p and label == l:
return i
# TODO: Avoid renaming in the pattern, use variable indices instead
renaming = self._collect_variable_renaming(pattern.expression) if self.rename else {}
self._internal_add(pattern, label, renaming) | python | def add(self, pattern: Pattern, label=None) -> None:
"""Add a new pattern to the matcher.
The optional label defaults to the pattern itself and is yielded during matching. The same pattern can be
added with different labels which means that every match for the pattern will result in every associated label
being yielded with that match individually.
Equivalent patterns with the same label are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern:
The pattern to add.
label:
An optional label for the pattern. Defaults to the pattern itself.
"""
if label is None:
label = pattern
for i, (p, l, _) in enumerate(self.patterns):
if pattern == p and label == l:
return i
# TODO: Avoid renaming in the pattern, use variable indices instead
renaming = self._collect_variable_renaming(pattern.expression) if self.rename else {}
self._internal_add(pattern, label, renaming) | [
"def",
"add",
"(",
"self",
",",
"pattern",
":",
"Pattern",
",",
"label",
"=",
"None",
")",
"->",
"None",
":",
"if",
"label",
"is",
"None",
":",
"label",
"=",
"pattern",
"for",
"i",
",",
"(",
"p",
",",
"l",
",",
"_",
")",
"in",
"enumerate",
"(",
"self",
".",
"patterns",
")",
":",
"if",
"pattern",
"==",
"p",
"and",
"label",
"==",
"l",
":",
"return",
"i",
"# TODO: Avoid renaming in the pattern, use variable indices instead",
"renaming",
"=",
"self",
".",
"_collect_variable_renaming",
"(",
"pattern",
".",
"expression",
")",
"if",
"self",
".",
"rename",
"else",
"{",
"}",
"self",
".",
"_internal_add",
"(",
"pattern",
",",
"label",
",",
"renaming",
")"
] | Add a new pattern to the matcher.
The optional label defaults to the pattern itself and is yielded during matching. The same pattern can be
added with different labels which means that every match for the pattern will result in every associated label
being yielded with that match individually.
Equivalent patterns with the same label are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern:
The pattern to add.
label:
An optional label for the pattern. Defaults to the pattern itself. | [
"Add",
"a",
"new",
"pattern",
"to",
"the",
"matcher",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L344-L367 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneMatcher._internal_add | def _internal_add(self, pattern: Pattern, label, renaming) -> int:
"""Add a new pattern to the matcher.
Equivalent patterns are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern: The pattern to add.
Returns:
The internal id for the pattern. This is mainly used by the :class:`CommutativeMatcher`.
"""
pattern_index = len(self.patterns)
renamed_constraints = [c.with_renamed_vars(renaming) for c in pattern.local_constraints]
constraint_indices = [self._add_constraint(c, pattern_index) for c in renamed_constraints]
self.patterns.append((pattern, label, constraint_indices))
self.pattern_vars.append(renaming)
pattern = rename_variables(pattern.expression, renaming)
state = self.root
patterns_stack = [deque([pattern])]
self._process_pattern_stack(state, patterns_stack, renamed_constraints, pattern_index)
return pattern_index | python | def _internal_add(self, pattern: Pattern, label, renaming) -> int:
"""Add a new pattern to the matcher.
Equivalent patterns are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern: The pattern to add.
Returns:
The internal id for the pattern. This is mainly used by the :class:`CommutativeMatcher`.
"""
pattern_index = len(self.patterns)
renamed_constraints = [c.with_renamed_vars(renaming) for c in pattern.local_constraints]
constraint_indices = [self._add_constraint(c, pattern_index) for c in renamed_constraints]
self.patterns.append((pattern, label, constraint_indices))
self.pattern_vars.append(renaming)
pattern = rename_variables(pattern.expression, renaming)
state = self.root
patterns_stack = [deque([pattern])]
self._process_pattern_stack(state, patterns_stack, renamed_constraints, pattern_index)
return pattern_index | [
"def",
"_internal_add",
"(",
"self",
",",
"pattern",
":",
"Pattern",
",",
"label",
",",
"renaming",
")",
"->",
"int",
":",
"pattern_index",
"=",
"len",
"(",
"self",
".",
"patterns",
")",
"renamed_constraints",
"=",
"[",
"c",
".",
"with_renamed_vars",
"(",
"renaming",
")",
"for",
"c",
"in",
"pattern",
".",
"local_constraints",
"]",
"constraint_indices",
"=",
"[",
"self",
".",
"_add_constraint",
"(",
"c",
",",
"pattern_index",
")",
"for",
"c",
"in",
"renamed_constraints",
"]",
"self",
".",
"patterns",
".",
"append",
"(",
"(",
"pattern",
",",
"label",
",",
"constraint_indices",
")",
")",
"self",
".",
"pattern_vars",
".",
"append",
"(",
"renaming",
")",
"pattern",
"=",
"rename_variables",
"(",
"pattern",
".",
"expression",
",",
"renaming",
")",
"state",
"=",
"self",
".",
"root",
"patterns_stack",
"=",
"[",
"deque",
"(",
"[",
"pattern",
"]",
")",
"]",
"self",
".",
"_process_pattern_stack",
"(",
"state",
",",
"patterns_stack",
",",
"renamed_constraints",
",",
"pattern_index",
")",
"return",
"pattern_index"
] | Add a new pattern to the matcher.
Equivalent patterns are not added again. However, patterns that are structurally equivalent,
but have different constraints or different variable names are distinguished by the matcher.
Args:
pattern: The pattern to add.
Returns:
The internal id for the pattern. This is mainly used by the :class:`CommutativeMatcher`. | [
"Add",
"a",
"new",
"pattern",
"to",
"the",
"matcher",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L369-L392 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneMatcher.match | def match(self, subject: Expression) -> Iterator[Tuple[Expression, Substitution]]:
"""Match the subject against all the matcher's patterns.
Args:
subject: The subject to match.
Yields:
For every match, a tuple of the matching pattern and the match substitution.
"""
return _MatchIter(self, subject) | python | def match(self, subject: Expression) -> Iterator[Tuple[Expression, Substitution]]:
"""Match the subject against all the matcher's patterns.
Args:
subject: The subject to match.
Yields:
For every match, a tuple of the matching pattern and the match substitution.
"""
return _MatchIter(self, subject) | [
"def",
"match",
"(",
"self",
",",
"subject",
":",
"Expression",
")",
"->",
"Iterator",
"[",
"Tuple",
"[",
"Expression",
",",
"Substitution",
"]",
"]",
":",
"return",
"_MatchIter",
"(",
"self",
",",
"subject",
")"
] | Match the subject against all the matcher's patterns.
Args:
subject: The subject to match.
Yields:
For every match, a tuple of the matching pattern and the match substitution. | [
"Match",
"the",
"subject",
"against",
"all",
"the",
"matcher",
"s",
"patterns",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L434-L443 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneMatcher._collect_variable_renaming | def _collect_variable_renaming(
cls, expression: Expression, position: List[int]=None, variables: Dict[str, str]=None
) -> Dict[str, str]:
"""Return renaming for the variables in the expression.
The variable names are generated according to the position of the variable in the expression. The goal is to
rename variables in structurally identical patterns so that the automaton contains less redundant states.
"""
if position is None:
position = [0]
if variables is None:
variables = {}
if getattr(expression, 'variable_name', False):
if expression.variable_name not in variables:
variables[expression.variable_name] = cls._get_name_for_position(position, variables.values())
position[-1] += 1
if isinstance(expression, Operation):
if isinstance(expression, CommutativeOperation):
for operand in op_iter(expression):
position.append(0)
cls._collect_variable_renaming(operand, position, variables)
position.pop()
else:
for operand in op_iter(expression):
cls._collect_variable_renaming(operand, position, variables)
return variables | python | def _collect_variable_renaming(
cls, expression: Expression, position: List[int]=None, variables: Dict[str, str]=None
) -> Dict[str, str]:
"""Return renaming for the variables in the expression.
The variable names are generated according to the position of the variable in the expression. The goal is to
rename variables in structurally identical patterns so that the automaton contains less redundant states.
"""
if position is None:
position = [0]
if variables is None:
variables = {}
if getattr(expression, 'variable_name', False):
if expression.variable_name not in variables:
variables[expression.variable_name] = cls._get_name_for_position(position, variables.values())
position[-1] += 1
if isinstance(expression, Operation):
if isinstance(expression, CommutativeOperation):
for operand in op_iter(expression):
position.append(0)
cls._collect_variable_renaming(operand, position, variables)
position.pop()
else:
for operand in op_iter(expression):
cls._collect_variable_renaming(operand, position, variables)
return variables | [
"def",
"_collect_variable_renaming",
"(",
"cls",
",",
"expression",
":",
"Expression",
",",
"position",
":",
"List",
"[",
"int",
"]",
"=",
"None",
",",
"variables",
":",
"Dict",
"[",
"str",
",",
"str",
"]",
"=",
"None",
")",
"->",
"Dict",
"[",
"str",
",",
"str",
"]",
":",
"if",
"position",
"is",
"None",
":",
"position",
"=",
"[",
"0",
"]",
"if",
"variables",
"is",
"None",
":",
"variables",
"=",
"{",
"}",
"if",
"getattr",
"(",
"expression",
",",
"'variable_name'",
",",
"False",
")",
":",
"if",
"expression",
".",
"variable_name",
"not",
"in",
"variables",
":",
"variables",
"[",
"expression",
".",
"variable_name",
"]",
"=",
"cls",
".",
"_get_name_for_position",
"(",
"position",
",",
"variables",
".",
"values",
"(",
")",
")",
"position",
"[",
"-",
"1",
"]",
"+=",
"1",
"if",
"isinstance",
"(",
"expression",
",",
"Operation",
")",
":",
"if",
"isinstance",
"(",
"expression",
",",
"CommutativeOperation",
")",
":",
"for",
"operand",
"in",
"op_iter",
"(",
"expression",
")",
":",
"position",
".",
"append",
"(",
"0",
")",
"cls",
".",
"_collect_variable_renaming",
"(",
"operand",
",",
"position",
",",
"variables",
")",
"position",
".",
"pop",
"(",
")",
"else",
":",
"for",
"operand",
"in",
"op_iter",
"(",
"expression",
")",
":",
"cls",
".",
"_collect_variable_renaming",
"(",
"operand",
",",
"position",
",",
"variables",
")",
"return",
"variables"
] | Return renaming for the variables in the expression.
The variable names are generated according to the position of the variable in the expression. The goal is to
rename variables in structurally identical patterns so that the automaton contains less redundant states. | [
"Return",
"renaming",
"for",
"the",
"variables",
"in",
"the",
"expression",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L532-L558 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneReplacer.add | def add(self, rule: 'functions.ReplacementRule') -> None:
"""Add a new rule to the replacer.
Args:
rule:
The rule to add.
"""
self.matcher.add(rule.pattern, rule.replacement) | python | def add(self, rule: 'functions.ReplacementRule') -> None:
"""Add a new rule to the replacer.
Args:
rule:
The rule to add.
"""
self.matcher.add(rule.pattern, rule.replacement) | [
"def",
"add",
"(",
"self",
",",
"rule",
":",
"'functions.ReplacementRule'",
")",
"->",
"None",
":",
"self",
".",
"matcher",
".",
"add",
"(",
"rule",
".",
"pattern",
",",
"rule",
".",
"replacement",
")"
] | Add a new rule to the replacer.
Args:
rule:
The rule to add. | [
"Add",
"a",
"new",
"rule",
"to",
"the",
"replacer",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L766-L773 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneReplacer.replace | def replace(self, expression: Expression, max_count: int=math.inf) -> Union[Expression, Sequence[Expression]]:
"""Replace all occurrences of the patterns according to the replacement rules.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule.
"""
replaced = True
replace_count = 0
while replaced and replace_count < max_count:
replaced = False
for subexpr, pos in preorder_iter_with_position(expression):
try:
replacement, subst = next(iter(self.matcher.match(subexpr)))
result = replacement(**subst)
expression = functions.replace(expression, pos, result)
replaced = True
break
except StopIteration:
pass
replace_count += 1
return expression | python | def replace(self, expression: Expression, max_count: int=math.inf) -> Union[Expression, Sequence[Expression]]:
"""Replace all occurrences of the patterns according to the replacement rules.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule.
"""
replaced = True
replace_count = 0
while replaced and replace_count < max_count:
replaced = False
for subexpr, pos in preorder_iter_with_position(expression):
try:
replacement, subst = next(iter(self.matcher.match(subexpr)))
result = replacement(**subst)
expression = functions.replace(expression, pos, result)
replaced = True
break
except StopIteration:
pass
replace_count += 1
return expression | [
"def",
"replace",
"(",
"self",
",",
"expression",
":",
"Expression",
",",
"max_count",
":",
"int",
"=",
"math",
".",
"inf",
")",
"->",
"Union",
"[",
"Expression",
",",
"Sequence",
"[",
"Expression",
"]",
"]",
":",
"replaced",
"=",
"True",
"replace_count",
"=",
"0",
"while",
"replaced",
"and",
"replace_count",
"<",
"max_count",
":",
"replaced",
"=",
"False",
"for",
"subexpr",
",",
"pos",
"in",
"preorder_iter_with_position",
"(",
"expression",
")",
":",
"try",
":",
"replacement",
",",
"subst",
"=",
"next",
"(",
"iter",
"(",
"self",
".",
"matcher",
".",
"match",
"(",
"subexpr",
")",
")",
")",
"result",
"=",
"replacement",
"(",
"*",
"*",
"subst",
")",
"expression",
"=",
"functions",
".",
"replace",
"(",
"expression",
",",
"pos",
",",
"result",
")",
"replaced",
"=",
"True",
"break",
"except",
"StopIteration",
":",
"pass",
"replace_count",
"+=",
"1",
"return",
"expression"
] | Replace all occurrences of the patterns according to the replacement rules.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule. | [
"Replace",
"all",
"occurrences",
"of",
"the",
"patterns",
"according",
"to",
"the",
"replacement",
"rules",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L775-L804 |
HPAC/matchpy | matchpy/matching/many_to_one.py | ManyToOneReplacer.replace_post_order | def replace_post_order(self, expression: Expression) -> Union[Expression, Sequence[Expression]]:
"""Replace all occurrences of the patterns according to the replacement rules.
Replaces innermost expressions first.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule.
"""
return self._replace_post_order(expression)[0] | python | def replace_post_order(self, expression: Expression) -> Union[Expression, Sequence[Expression]]:
"""Replace all occurrences of the patterns according to the replacement rules.
Replaces innermost expressions first.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule.
"""
return self._replace_post_order(expression)[0] | [
"def",
"replace_post_order",
"(",
"self",
",",
"expression",
":",
"Expression",
")",
"->",
"Union",
"[",
"Expression",
",",
"Sequence",
"[",
"Expression",
"]",
"]",
":",
"return",
"self",
".",
"_replace_post_order",
"(",
"expression",
")",
"[",
"0",
"]"
] | Replace all occurrences of the patterns according to the replacement rules.
Replaces innermost expressions first.
Args:
expression:
The expression to which the replacement rules are applied.
max_count:
If given, at most *max_count* applications of the rules are performed. Otherwise, the rules
are applied until there is no more match. If the set of replacement rules is not confluent,
the replacement might not terminate without a *max_count* set.
Returns:
The resulting expression after the application of the replacement rules. This can also be a sequence of
expressions, if the root expression is replaced with a sequence of expressions by a rule. | [
"Replace",
"all",
"occurrences",
"of",
"the",
"patterns",
"according",
"to",
"the",
"replacement",
"rules",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L806-L823 |
HPAC/matchpy | matchpy/matching/many_to_one.py | CommutativeMatcher.bipartite_as_graph | def bipartite_as_graph(self) -> Graph: # pragma: no cover
"""Returns a :class:`graphviz.Graph` representation of this bipartite graph."""
if Graph is None:
raise ImportError('The graphviz package is required to draw the graph.')
graph = Graph()
nodes_left = {} # type: Dict[TLeft, str]
nodes_right = {} # type: Dict[TRight, str]
node_id = 0
for (left, right), value in self.bipartite._edges.items():
if left not in nodes_left:
name = 'node{:d}'.format(node_id)
nodes_left[left] = name
label = str(self.subjects_by_id[left])
graph.node(name, label=label)
node_id += 1
if right not in nodes_right:
name = 'node{:d}'.format(node_id)
nodes_right[right] = name
label = str(self.automaton.patterns[right][0])
graph.node(name, label=label)
node_id += 1
edge_label = value is not True and str(value) or ''
graph.edge(nodes_left[left], nodes_right[right], edge_label)
return graph | python | def bipartite_as_graph(self) -> Graph: # pragma: no cover
"""Returns a :class:`graphviz.Graph` representation of this bipartite graph."""
if Graph is None:
raise ImportError('The graphviz package is required to draw the graph.')
graph = Graph()
nodes_left = {} # type: Dict[TLeft, str]
nodes_right = {} # type: Dict[TRight, str]
node_id = 0
for (left, right), value in self.bipartite._edges.items():
if left not in nodes_left:
name = 'node{:d}'.format(node_id)
nodes_left[left] = name
label = str(self.subjects_by_id[left])
graph.node(name, label=label)
node_id += 1
if right not in nodes_right:
name = 'node{:d}'.format(node_id)
nodes_right[right] = name
label = str(self.automaton.patterns[right][0])
graph.node(name, label=label)
node_id += 1
edge_label = value is not True and str(value) or ''
graph.edge(nodes_left[left], nodes_right[right], edge_label)
return graph | [
"def",
"bipartite_as_graph",
"(",
"self",
")",
"->",
"Graph",
":",
"# pragma: no cover",
"if",
"Graph",
"is",
"None",
":",
"raise",
"ImportError",
"(",
"'The graphviz package is required to draw the graph.'",
")",
"graph",
"=",
"Graph",
"(",
")",
"nodes_left",
"=",
"{",
"}",
"# type: Dict[TLeft, str]",
"nodes_right",
"=",
"{",
"}",
"# type: Dict[TRight, str]",
"node_id",
"=",
"0",
"for",
"(",
"left",
",",
"right",
")",
",",
"value",
"in",
"self",
".",
"bipartite",
".",
"_edges",
".",
"items",
"(",
")",
":",
"if",
"left",
"not",
"in",
"nodes_left",
":",
"name",
"=",
"'node{:d}'",
".",
"format",
"(",
"node_id",
")",
"nodes_left",
"[",
"left",
"]",
"=",
"name",
"label",
"=",
"str",
"(",
"self",
".",
"subjects_by_id",
"[",
"left",
"]",
")",
"graph",
".",
"node",
"(",
"name",
",",
"label",
"=",
"label",
")",
"node_id",
"+=",
"1",
"if",
"right",
"not",
"in",
"nodes_right",
":",
"name",
"=",
"'node{:d}'",
".",
"format",
"(",
"node_id",
")",
"nodes_right",
"[",
"right",
"]",
"=",
"name",
"label",
"=",
"str",
"(",
"self",
".",
"automaton",
".",
"patterns",
"[",
"right",
"]",
"[",
"0",
"]",
")",
"graph",
".",
"node",
"(",
"name",
",",
"label",
"=",
"label",
")",
"node_id",
"+=",
"1",
"edge_label",
"=",
"value",
"is",
"not",
"True",
"and",
"str",
"(",
"value",
")",
"or",
"''",
"graph",
".",
"edge",
"(",
"nodes_left",
"[",
"left",
"]",
",",
"nodes_right",
"[",
"right",
"]",
",",
"edge_label",
")",
"return",
"graph"
] | Returns a :class:`graphviz.Graph` representation of this bipartite graph. | [
"Returns",
"a",
":",
"class",
":",
"graphviz",
".",
"Graph",
"representation",
"of",
"this",
"bipartite",
"graph",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L1058-L1081 |
HPAC/matchpy | matchpy/matching/many_to_one.py | CommutativeMatcher.concrete_bipartite_as_graph | def concrete_bipartite_as_graph(self, subjects, patterns) -> Graph: # pragma: no cover
"""Returns a :class:`graphviz.Graph` representation of this bipartite graph."""
if Graph is None:
raise ImportError('The graphviz package is required to draw the graph.')
bipartite = self._build_bipartite(subjects, patterns)
graph = Graph()
nodes_left = {} # type: Dict[TLeft, str]
nodes_right = {} # type: Dict[TRight, str]
node_id = 0
for (left, right), value in bipartite._edges.items():
if left not in nodes_left:
subject_id, i = left
name = 'node{:d}'.format(node_id)
nodes_left[left] = name
label = '{}, {}'.format(i, self.subjects_by_id[subject_id])
graph.node(name, label=label)
node_id += 1
if right not in nodes_right:
pattern, i = right
name = 'node{:d}'.format(node_id)
nodes_right[right] = name
label = '{}, {}'.format(i, self.automaton.patterns[pattern][0])
graph.node(name, label=label)
node_id += 1
edge_label = value is not True and str(value) or ''
graph.edge(nodes_left[left], nodes_right[right], edge_label)
return graph | python | def concrete_bipartite_as_graph(self, subjects, patterns) -> Graph: # pragma: no cover
"""Returns a :class:`graphviz.Graph` representation of this bipartite graph."""
if Graph is None:
raise ImportError('The graphviz package is required to draw the graph.')
bipartite = self._build_bipartite(subjects, patterns)
graph = Graph()
nodes_left = {} # type: Dict[TLeft, str]
nodes_right = {} # type: Dict[TRight, str]
node_id = 0
for (left, right), value in bipartite._edges.items():
if left not in nodes_left:
subject_id, i = left
name = 'node{:d}'.format(node_id)
nodes_left[left] = name
label = '{}, {}'.format(i, self.subjects_by_id[subject_id])
graph.node(name, label=label)
node_id += 1
if right not in nodes_right:
pattern, i = right
name = 'node{:d}'.format(node_id)
nodes_right[right] = name
label = '{}, {}'.format(i, self.automaton.patterns[pattern][0])
graph.node(name, label=label)
node_id += 1
edge_label = value is not True and str(value) or ''
graph.edge(nodes_left[left], nodes_right[right], edge_label)
return graph | [
"def",
"concrete_bipartite_as_graph",
"(",
"self",
",",
"subjects",
",",
"patterns",
")",
"->",
"Graph",
":",
"# pragma: no cover",
"if",
"Graph",
"is",
"None",
":",
"raise",
"ImportError",
"(",
"'The graphviz package is required to draw the graph.'",
")",
"bipartite",
"=",
"self",
".",
"_build_bipartite",
"(",
"subjects",
",",
"patterns",
")",
"graph",
"=",
"Graph",
"(",
")",
"nodes_left",
"=",
"{",
"}",
"# type: Dict[TLeft, str]",
"nodes_right",
"=",
"{",
"}",
"# type: Dict[TRight, str]",
"node_id",
"=",
"0",
"for",
"(",
"left",
",",
"right",
")",
",",
"value",
"in",
"bipartite",
".",
"_edges",
".",
"items",
"(",
")",
":",
"if",
"left",
"not",
"in",
"nodes_left",
":",
"subject_id",
",",
"i",
"=",
"left",
"name",
"=",
"'node{:d}'",
".",
"format",
"(",
"node_id",
")",
"nodes_left",
"[",
"left",
"]",
"=",
"name",
"label",
"=",
"'{}, {}'",
".",
"format",
"(",
"i",
",",
"self",
".",
"subjects_by_id",
"[",
"subject_id",
"]",
")",
"graph",
".",
"node",
"(",
"name",
",",
"label",
"=",
"label",
")",
"node_id",
"+=",
"1",
"if",
"right",
"not",
"in",
"nodes_right",
":",
"pattern",
",",
"i",
"=",
"right",
"name",
"=",
"'node{:d}'",
".",
"format",
"(",
"node_id",
")",
"nodes_right",
"[",
"right",
"]",
"=",
"name",
"label",
"=",
"'{}, {}'",
".",
"format",
"(",
"i",
",",
"self",
".",
"automaton",
".",
"patterns",
"[",
"pattern",
"]",
"[",
"0",
"]",
")",
"graph",
".",
"node",
"(",
"name",
",",
"label",
"=",
"label",
")",
"node_id",
"+=",
"1",
"edge_label",
"=",
"value",
"is",
"not",
"True",
"and",
"str",
"(",
"value",
")",
"or",
"''",
"graph",
".",
"edge",
"(",
"nodes_left",
"[",
"left",
"]",
",",
"nodes_right",
"[",
"right",
"]",
",",
"edge_label",
")",
"return",
"graph"
] | Returns a :class:`graphviz.Graph` representation of this bipartite graph. | [
"Returns",
"a",
":",
"class",
":",
"graphviz",
".",
"Graph",
"representation",
"of",
"this",
"bipartite",
"graph",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/matching/many_to_one.py#L1083-L1109 |
HPAC/matchpy | matchpy/expressions/expressions.py | Expression.collect_variables | def collect_variables(self, variables: MultisetOfVariables) -> None:
"""Recursively adds all variables occuring in the expression to the given multiset.
This is used internally by `variables`. Needs to be overwritten by inheriting container expression classes.
This method can be used when gathering the `variables` of multiple expressions, because only one multiset
needs to be created and that is more efficient.
Args:
variables:
Multiset of variables. All variables contained in the expression are recursively added to this multiset.
"""
if self.variable_name is not None:
variables.add(self.variable_name) | python | def collect_variables(self, variables: MultisetOfVariables) -> None:
"""Recursively adds all variables occuring in the expression to the given multiset.
This is used internally by `variables`. Needs to be overwritten by inheriting container expression classes.
This method can be used when gathering the `variables` of multiple expressions, because only one multiset
needs to be created and that is more efficient.
Args:
variables:
Multiset of variables. All variables contained in the expression are recursively added to this multiset.
"""
if self.variable_name is not None:
variables.add(self.variable_name) | [
"def",
"collect_variables",
"(",
"self",
",",
"variables",
":",
"MultisetOfVariables",
")",
"->",
"None",
":",
"if",
"self",
".",
"variable_name",
"is",
"not",
"None",
":",
"variables",
".",
"add",
"(",
"self",
".",
"variable_name",
")"
] | Recursively adds all variables occuring in the expression to the given multiset.
This is used internally by `variables`. Needs to be overwritten by inheriting container expression classes.
This method can be used when gathering the `variables` of multiple expressions, because only one multiset
needs to be created and that is more efficient.
Args:
variables:
Multiset of variables. All variables contained in the expression are recursively added to this multiset. | [
"Recursively",
"adds",
"all",
"variables",
"occuring",
"in",
"the",
"expression",
"to",
"the",
"given",
"multiset",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/expressions/expressions.py#L97-L109 |
HPAC/matchpy | matchpy/expressions/expressions.py | _OperationMeta._simplify | def _simplify(cls, operands: List[Expression]) -> bool:
"""Flatten/sort the operands of associative/commutative operations.
Returns:
True iff *one_identity* is True and the operation contains a single
argument that is not a sequence wildcard.
"""
if cls.associative:
new_operands = [] # type: List[Expression]
for operand in operands:
if isinstance(operand, cls):
new_operands.extend(operand.operands) # type: ignore
else:
new_operands.append(operand)
operands.clear()
operands.extend(new_operands)
if cls.one_identity and len(operands) == 1:
expr = operands[0]
if not isinstance(expr, Wildcard) or (expr.min_count == 1 and expr.fixed_size):
return True
if cls.commutative:
operands.sort()
return False | python | def _simplify(cls, operands: List[Expression]) -> bool:
"""Flatten/sort the operands of associative/commutative operations.
Returns:
True iff *one_identity* is True and the operation contains a single
argument that is not a sequence wildcard.
"""
if cls.associative:
new_operands = [] # type: List[Expression]
for operand in operands:
if isinstance(operand, cls):
new_operands.extend(operand.operands) # type: ignore
else:
new_operands.append(operand)
operands.clear()
operands.extend(new_operands)
if cls.one_identity and len(operands) == 1:
expr = operands[0]
if not isinstance(expr, Wildcard) or (expr.min_count == 1 and expr.fixed_size):
return True
if cls.commutative:
operands.sort()
return False | [
"def",
"_simplify",
"(",
"cls",
",",
"operands",
":",
"List",
"[",
"Expression",
"]",
")",
"->",
"bool",
":",
"if",
"cls",
".",
"associative",
":",
"new_operands",
"=",
"[",
"]",
"# type: List[Expression]",
"for",
"operand",
"in",
"operands",
":",
"if",
"isinstance",
"(",
"operand",
",",
"cls",
")",
":",
"new_operands",
".",
"extend",
"(",
"operand",
".",
"operands",
")",
"# type: ignore",
"else",
":",
"new_operands",
".",
"append",
"(",
"operand",
")",
"operands",
".",
"clear",
"(",
")",
"operands",
".",
"extend",
"(",
"new_operands",
")",
"if",
"cls",
".",
"one_identity",
"and",
"len",
"(",
"operands",
")",
"==",
"1",
":",
"expr",
"=",
"operands",
"[",
"0",
"]",
"if",
"not",
"isinstance",
"(",
"expr",
",",
"Wildcard",
")",
"or",
"(",
"expr",
".",
"min_count",
"==",
"1",
"and",
"expr",
".",
"fixed_size",
")",
":",
"return",
"True",
"if",
"cls",
".",
"commutative",
":",
"operands",
".",
"sort",
"(",
")",
"return",
"False"
] | Flatten/sort the operands of associative/commutative operations.
Returns:
True iff *one_identity* is True and the operation contains a single
argument that is not a sequence wildcard. | [
"Flatten",
"/",
"sort",
"the",
"operands",
"of",
"associative",
"/",
"commutative",
"operations",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/expressions/expressions.py#L287-L313 |
HPAC/matchpy | matchpy/expressions/expressions.py | Operation.new | def new(
name: str,
arity: Arity,
class_name: str=None,
*,
associative: bool=False,
commutative: bool=False,
one_identity: bool=False,
infix: bool=False
) -> Type['Operation']:
"""Utility method to create a new operation type.
Example:
>>> Times = Operation.new('*', Arity.polyadic, 'Times', associative=True, commutative=True, one_identity=True)
>>> Times
Times['*', Arity(min_count=2, fixed_size=False), associative, commutative, one_identity]
>>> str(Times(Symbol('a'), Symbol('b')))
'*(a, b)'
Args:
name:
Name or symbol for the operator. Will be used as name for the new class if
`class_name` is not specified.
arity:
The arity of the operator as explained in the documentation of `Operation`.
class_name:
Name for the new operation class to be used instead of name. This argument
is required if `name` is not a valid python identifier.
Keyword Args:
associative:
See :attr:`~Operation.associative`.
commutative:
See :attr:`~Operation.commutative`.
one_identity:
See :attr:`~Operation.one_identity`.
infix:
See :attr:`~Operation.infix`.
Raises:
ValueError: if the class name of the operation is not a valid class identifier.
"""
class_name = class_name or name
if not class_name.isidentifier() or keyword.iskeyword(class_name):
raise ValueError("Invalid identifier for new operator class.")
return type(
class_name, (Operation, ), {
'name': name,
'arity': arity,
'associative': associative,
'commutative': commutative,
'one_identity': one_identity,
'infix': infix
}
) | python | def new(
name: str,
arity: Arity,
class_name: str=None,
*,
associative: bool=False,
commutative: bool=False,
one_identity: bool=False,
infix: bool=False
) -> Type['Operation']:
"""Utility method to create a new operation type.
Example:
>>> Times = Operation.new('*', Arity.polyadic, 'Times', associative=True, commutative=True, one_identity=True)
>>> Times
Times['*', Arity(min_count=2, fixed_size=False), associative, commutative, one_identity]
>>> str(Times(Symbol('a'), Symbol('b')))
'*(a, b)'
Args:
name:
Name or symbol for the operator. Will be used as name for the new class if
`class_name` is not specified.
arity:
The arity of the operator as explained in the documentation of `Operation`.
class_name:
Name for the new operation class to be used instead of name. This argument
is required if `name` is not a valid python identifier.
Keyword Args:
associative:
See :attr:`~Operation.associative`.
commutative:
See :attr:`~Operation.commutative`.
one_identity:
See :attr:`~Operation.one_identity`.
infix:
See :attr:`~Operation.infix`.
Raises:
ValueError: if the class name of the operation is not a valid class identifier.
"""
class_name = class_name or name
if not class_name.isidentifier() or keyword.iskeyword(class_name):
raise ValueError("Invalid identifier for new operator class.")
return type(
class_name, (Operation, ), {
'name': name,
'arity': arity,
'associative': associative,
'commutative': commutative,
'one_identity': one_identity,
'infix': infix
}
) | [
"def",
"new",
"(",
"name",
":",
"str",
",",
"arity",
":",
"Arity",
",",
"class_name",
":",
"str",
"=",
"None",
",",
"*",
",",
"associative",
":",
"bool",
"=",
"False",
",",
"commutative",
":",
"bool",
"=",
"False",
",",
"one_identity",
":",
"bool",
"=",
"False",
",",
"infix",
":",
"bool",
"=",
"False",
")",
"->",
"Type",
"[",
"'Operation'",
"]",
":",
"class_name",
"=",
"class_name",
"or",
"name",
"if",
"not",
"class_name",
".",
"isidentifier",
"(",
")",
"or",
"keyword",
".",
"iskeyword",
"(",
"class_name",
")",
":",
"raise",
"ValueError",
"(",
"\"Invalid identifier for new operator class.\"",
")",
"return",
"type",
"(",
"class_name",
",",
"(",
"Operation",
",",
")",
",",
"{",
"'name'",
":",
"name",
",",
"'arity'",
":",
"arity",
",",
"'associative'",
":",
"associative",
",",
"'commutative'",
":",
"commutative",
",",
"'one_identity'",
":",
"one_identity",
",",
"'infix'",
":",
"infix",
"}",
")"
] | Utility method to create a new operation type.
Example:
>>> Times = Operation.new('*', Arity.polyadic, 'Times', associative=True, commutative=True, one_identity=True)
>>> Times
Times['*', Arity(min_count=2, fixed_size=False), associative, commutative, one_identity]
>>> str(Times(Symbol('a'), Symbol('b')))
'*(a, b)'
Args:
name:
Name or symbol for the operator. Will be used as name for the new class if
`class_name` is not specified.
arity:
The arity of the operator as explained in the documentation of `Operation`.
class_name:
Name for the new operation class to be used instead of name. This argument
is required if `name` is not a valid python identifier.
Keyword Args:
associative:
See :attr:`~Operation.associative`.
commutative:
See :attr:`~Operation.commutative`.
one_identity:
See :attr:`~Operation.one_identity`.
infix:
See :attr:`~Operation.infix`.
Raises:
ValueError: if the class name of the operation is not a valid class identifier. | [
"Utility",
"method",
"to",
"create",
"a",
"new",
"operation",
"type",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/expressions/expressions.py#L426-L482 |
HPAC/matchpy | matchpy/expressions/expressions.py | Wildcard.optional | def optional(name, default) -> 'Wildcard':
"""Create a `Wildcard` that matches a single argument with a default value.
If the wildcard does not match, the substitution will contain the
default value instead.
Args:
name:
The name for the wildcard.
default:
The default value of the wildcard.
Returns:
A n optional wildcard.
"""
return Wildcard(min_count=1, fixed_size=True, variable_name=name, optional=default) | python | def optional(name, default) -> 'Wildcard':
"""Create a `Wildcard` that matches a single argument with a default value.
If the wildcard does not match, the substitution will contain the
default value instead.
Args:
name:
The name for the wildcard.
default:
The default value of the wildcard.
Returns:
A n optional wildcard.
"""
return Wildcard(min_count=1, fixed_size=True, variable_name=name, optional=default) | [
"def",
"optional",
"(",
"name",
",",
"default",
")",
"->",
"'Wildcard'",
":",
"return",
"Wildcard",
"(",
"min_count",
"=",
"1",
",",
"fixed_size",
"=",
"True",
",",
"variable_name",
"=",
"name",
",",
"optional",
"=",
"default",
")"
] | Create a `Wildcard` that matches a single argument with a default value.
If the wildcard does not match, the substitution will contain the
default value instead.
Args:
name:
The name for the wildcard.
default:
The default value of the wildcard.
Returns:
A n optional wildcard. | [
"Create",
"a",
"Wildcard",
"that",
"matches",
"a",
"single",
"argument",
"with",
"a",
"default",
"value",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/expressions/expressions.py#L755-L770 |
HPAC/matchpy | matchpy/expressions/expressions.py | Wildcard.symbol | def symbol(name: str=None, symbol_type: Type[Symbol]=Symbol) -> 'SymbolWildcard':
"""Create a `SymbolWildcard` that matches a single `Symbol` argument.
Args:
name:
Optional variable name for the wildcard.
symbol_type:
An optional subclass of `Symbol` to further limit which kind of symbols are
matched by the wildcard.
Returns:
A `SymbolWildcard` that matches the *symbol_type*.
"""
if isinstance(name, type) and issubclass(name, Symbol) and symbol_type is Symbol:
return SymbolWildcard(name)
return SymbolWildcard(symbol_type, variable_name=name) | python | def symbol(name: str=None, symbol_type: Type[Symbol]=Symbol) -> 'SymbolWildcard':
"""Create a `SymbolWildcard` that matches a single `Symbol` argument.
Args:
name:
Optional variable name for the wildcard.
symbol_type:
An optional subclass of `Symbol` to further limit which kind of symbols are
matched by the wildcard.
Returns:
A `SymbolWildcard` that matches the *symbol_type*.
"""
if isinstance(name, type) and issubclass(name, Symbol) and symbol_type is Symbol:
return SymbolWildcard(name)
return SymbolWildcard(symbol_type, variable_name=name) | [
"def",
"symbol",
"(",
"name",
":",
"str",
"=",
"None",
",",
"symbol_type",
":",
"Type",
"[",
"Symbol",
"]",
"=",
"Symbol",
")",
"->",
"'SymbolWildcard'",
":",
"if",
"isinstance",
"(",
"name",
",",
"type",
")",
"and",
"issubclass",
"(",
"name",
",",
"Symbol",
")",
"and",
"symbol_type",
"is",
"Symbol",
":",
"return",
"SymbolWildcard",
"(",
"name",
")",
"return",
"SymbolWildcard",
"(",
"symbol_type",
",",
"variable_name",
"=",
"name",
")"
] | Create a `SymbolWildcard` that matches a single `Symbol` argument.
Args:
name:
Optional variable name for the wildcard.
symbol_type:
An optional subclass of `Symbol` to further limit which kind of symbols are
matched by the wildcard.
Returns:
A `SymbolWildcard` that matches the *symbol_type*. | [
"Create",
"a",
"SymbolWildcard",
"that",
"matches",
"a",
"single",
"Symbol",
"argument",
"."
] | train | https://github.com/HPAC/matchpy/blob/06b2ec50ee0efdf3dd183768c0ffdb51b7efc393/matchpy/expressions/expressions.py#L773-L788 |
optimizely/optimizely-client-python | optimizely/client.py | Client.request | def request(self, method, url_parts, headers=None, data=None):
""" Method for making requests to the Optimizely API
"""
if method in self.ALLOWED_REQUESTS:
# add request token header
headers = headers or {}
# test if Oauth token
if self.token_type == 'legacy':
headers.update(
{'Token': self.api_key,
'User-Agent': 'optimizely-client-python/0.1.1'})
elif self.token_type == 'oauth':
headers.update(
{'Authorization': 'Bearer ' + self.api_key,
'User-Agent': 'optimizely-client-python/0.1.1'})
else:
raise ValueError(
'{} is not a valid token type.'.format(self.token_type))
# make request and return parsed response
url = urlparse.urljoin(
self.api_base,
'/'.join([str(url_part) for url_part in url_parts])
)
return self.parse_response(
getattr(requests, method)(url, headers=headers, data=data)
)
else:
raise error.BadRequestError(
'%s is not a valid request type.' % method) | python | def request(self, method, url_parts, headers=None, data=None):
""" Method for making requests to the Optimizely API
"""
if method in self.ALLOWED_REQUESTS:
# add request token header
headers = headers or {}
# test if Oauth token
if self.token_type == 'legacy':
headers.update(
{'Token': self.api_key,
'User-Agent': 'optimizely-client-python/0.1.1'})
elif self.token_type == 'oauth':
headers.update(
{'Authorization': 'Bearer ' + self.api_key,
'User-Agent': 'optimizely-client-python/0.1.1'})
else:
raise ValueError(
'{} is not a valid token type.'.format(self.token_type))
# make request and return parsed response
url = urlparse.urljoin(
self.api_base,
'/'.join([str(url_part) for url_part in url_parts])
)
return self.parse_response(
getattr(requests, method)(url, headers=headers, data=data)
)
else:
raise error.BadRequestError(
'%s is not a valid request type.' % method) | [
"def",
"request",
"(",
"self",
",",
"method",
",",
"url_parts",
",",
"headers",
"=",
"None",
",",
"data",
"=",
"None",
")",
":",
"if",
"method",
"in",
"self",
".",
"ALLOWED_REQUESTS",
":",
"# add request token header",
"headers",
"=",
"headers",
"or",
"{",
"}",
"# test if Oauth token",
"if",
"self",
".",
"token_type",
"==",
"'legacy'",
":",
"headers",
".",
"update",
"(",
"{",
"'Token'",
":",
"self",
".",
"api_key",
",",
"'User-Agent'",
":",
"'optimizely-client-python/0.1.1'",
"}",
")",
"elif",
"self",
".",
"token_type",
"==",
"'oauth'",
":",
"headers",
".",
"update",
"(",
"{",
"'Authorization'",
":",
"'Bearer '",
"+",
"self",
".",
"api_key",
",",
"'User-Agent'",
":",
"'optimizely-client-python/0.1.1'",
"}",
")",
"else",
":",
"raise",
"ValueError",
"(",
"'{} is not a valid token type.'",
".",
"format",
"(",
"self",
".",
"token_type",
")",
")",
"# make request and return parsed response",
"url",
"=",
"urlparse",
".",
"urljoin",
"(",
"self",
".",
"api_base",
",",
"'/'",
".",
"join",
"(",
"[",
"str",
"(",
"url_part",
")",
"for",
"url_part",
"in",
"url_parts",
"]",
")",
")",
"return",
"self",
".",
"parse_response",
"(",
"getattr",
"(",
"requests",
",",
"method",
")",
"(",
"url",
",",
"headers",
"=",
"headers",
",",
"data",
"=",
"data",
")",
")",
"else",
":",
"raise",
"error",
".",
"BadRequestError",
"(",
"'%s is not a valid request type.'",
"%",
"method",
")"
] | Method for making requests to the Optimizely API | [
"Method",
"for",
"making",
"requests",
"to",
"the",
"Optimizely",
"API"
] | train | https://github.com/optimizely/optimizely-client-python/blob/c4a121e8ac66e44f6ef4ad4959ef46ed3992708a/optimizely/client.py#L45-L74 |
optimizely/optimizely-client-python | optimizely/client.py | Client.parse_response | def parse_response(resp):
""" Method to parse response from the Optimizely API and
return results as JSON. Errors are thrown for various
errors that the API can throw.
"""
if resp.status_code in [200, 201, 202]:
return resp.json()
elif resp.status_code == 204:
return None
elif resp.status_code == 400:
raise error.BadRequestError(resp.text)
elif resp.status_code == 401:
raise error.UnauthorizedError(resp.text)
elif resp.status_code == 403:
raise error.ForbiddenError(resp.text)
elif resp.status_code == 404:
raise error.NotFoundError(resp.text)
elif resp.status_code == 429:
raise error.TooManyRequestsError(resp.text)
elif resp.status_code == 503:
raise error.ServiceUnavailableError(resp.text)
else:
raise error.OptimizelyError(resp.text) | python | def parse_response(resp):
""" Method to parse response from the Optimizely API and
return results as JSON. Errors are thrown for various
errors that the API can throw.
"""
if resp.status_code in [200, 201, 202]:
return resp.json()
elif resp.status_code == 204:
return None
elif resp.status_code == 400:
raise error.BadRequestError(resp.text)
elif resp.status_code == 401:
raise error.UnauthorizedError(resp.text)
elif resp.status_code == 403:
raise error.ForbiddenError(resp.text)
elif resp.status_code == 404:
raise error.NotFoundError(resp.text)
elif resp.status_code == 429:
raise error.TooManyRequestsError(resp.text)
elif resp.status_code == 503:
raise error.ServiceUnavailableError(resp.text)
else:
raise error.OptimizelyError(resp.text) | [
"def",
"parse_response",
"(",
"resp",
")",
":",
"if",
"resp",
".",
"status_code",
"in",
"[",
"200",
",",
"201",
",",
"202",
"]",
":",
"return",
"resp",
".",
"json",
"(",
")",
"elif",
"resp",
".",
"status_code",
"==",
"204",
":",
"return",
"None",
"elif",
"resp",
".",
"status_code",
"==",
"400",
":",
"raise",
"error",
".",
"BadRequestError",
"(",
"resp",
".",
"text",
")",
"elif",
"resp",
".",
"status_code",
"==",
"401",
":",
"raise",
"error",
".",
"UnauthorizedError",
"(",
"resp",
".",
"text",
")",
"elif",
"resp",
".",
"status_code",
"==",
"403",
":",
"raise",
"error",
".",
"ForbiddenError",
"(",
"resp",
".",
"text",
")",
"elif",
"resp",
".",
"status_code",
"==",
"404",
":",
"raise",
"error",
".",
"NotFoundError",
"(",
"resp",
".",
"text",
")",
"elif",
"resp",
".",
"status_code",
"==",
"429",
":",
"raise",
"error",
".",
"TooManyRequestsError",
"(",
"resp",
".",
"text",
")",
"elif",
"resp",
".",
"status_code",
"==",
"503",
":",
"raise",
"error",
".",
"ServiceUnavailableError",
"(",
"resp",
".",
"text",
")",
"else",
":",
"raise",
"error",
".",
"OptimizelyError",
"(",
"resp",
".",
"text",
")"
] | Method to parse response from the Optimizely API and
return results as JSON. Errors are thrown for various
errors that the API can throw. | [
"Method",
"to",
"parse",
"response",
"from",
"the",
"Optimizely",
"API",
"and",
"return",
"results",
"as",
"JSON",
".",
"Errors",
"are",
"thrown",
"for",
"various",
"errors",
"that",
"the",
"API",
"can",
"throw",
"."
] | train | https://github.com/optimizely/optimizely-client-python/blob/c4a121e8ac66e44f6ef4ad4959ef46ed3992708a/optimizely/client.py#L77-L99 |
sirrice/pygg | pygg/pygg.py | _to_r | def _to_r(o, as_data=False, level=0):
"""Helper function to convert python data structures to R equivalents
TODO: a single model for transforming to r to handle
* function args
* lists as function args
"""
if o is None:
return "NA"
if isinstance(o, basestring):
return o
if hasattr(o, "r"):
# bridge to @property r on GGStatement(s)
return o.r
elif isinstance(o, bool):
return "TRUE" if o else "FALSE"
elif isinstance(o, (list, tuple)):
inner = ",".join([_to_r(x, True, level+1) for x in o])
return "c({})".format(inner) if as_data else inner
elif isinstance(o, dict):
inner = ",".join(["{}={}".format(k, _to_r(v, True, level+1))
for k, v in sorted(o.iteritems(), key=lambda x: x[0])])
return "list({})".format(inner) if as_data else inner
return str(o) | python | def _to_r(o, as_data=False, level=0):
"""Helper function to convert python data structures to R equivalents
TODO: a single model for transforming to r to handle
* function args
* lists as function args
"""
if o is None:
return "NA"
if isinstance(o, basestring):
return o
if hasattr(o, "r"):
# bridge to @property r on GGStatement(s)
return o.r
elif isinstance(o, bool):
return "TRUE" if o else "FALSE"
elif isinstance(o, (list, tuple)):
inner = ",".join([_to_r(x, True, level+1) for x in o])
return "c({})".format(inner) if as_data else inner
elif isinstance(o, dict):
inner = ",".join(["{}={}".format(k, _to_r(v, True, level+1))
for k, v in sorted(o.iteritems(), key=lambda x: x[0])])
return "list({})".format(inner) if as_data else inner
return str(o) | [
"def",
"_to_r",
"(",
"o",
",",
"as_data",
"=",
"False",
",",
"level",
"=",
"0",
")",
":",
"if",
"o",
"is",
"None",
":",
"return",
"\"NA\"",
"if",
"isinstance",
"(",
"o",
",",
"basestring",
")",
":",
"return",
"o",
"if",
"hasattr",
"(",
"o",
",",
"\"r\"",
")",
":",
"# bridge to @property r on GGStatement(s)",
"return",
"o",
".",
"r",
"elif",
"isinstance",
"(",
"o",
",",
"bool",
")",
":",
"return",
"\"TRUE\"",
"if",
"o",
"else",
"\"FALSE\"",
"elif",
"isinstance",
"(",
"o",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"inner",
"=",
"\",\"",
".",
"join",
"(",
"[",
"_to_r",
"(",
"x",
",",
"True",
",",
"level",
"+",
"1",
")",
"for",
"x",
"in",
"o",
"]",
")",
"return",
"\"c({})\"",
".",
"format",
"(",
"inner",
")",
"if",
"as_data",
"else",
"inner",
"elif",
"isinstance",
"(",
"o",
",",
"dict",
")",
":",
"inner",
"=",
"\",\"",
".",
"join",
"(",
"[",
"\"{}={}\"",
".",
"format",
"(",
"k",
",",
"_to_r",
"(",
"v",
",",
"True",
",",
"level",
"+",
"1",
")",
")",
"for",
"k",
",",
"v",
"in",
"sorted",
"(",
"o",
".",
"iteritems",
"(",
")",
",",
"key",
"=",
"lambda",
"x",
":",
"x",
"[",
"0",
"]",
")",
"]",
")",
"return",
"\"list({})\"",
".",
"format",
"(",
"inner",
")",
"if",
"as_data",
"else",
"inner",
"return",
"str",
"(",
"o",
")"
] | Helper function to convert python data structures to R equivalents
TODO: a single model for transforming to r to handle
* function args
* lists as function args | [
"Helper",
"function",
"to",
"convert",
"python",
"data",
"structures",
"to",
"R",
"equivalents"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L32-L55 |
sirrice/pygg | pygg/pygg.py | data_sql | def data_sql(db, sql):
"""Load file using RPostgreSQL
Place to edit if want to add more database backend support
"""
if not db:
if sql:
print "ERR: -db option must be set if using -sql"
return ""
cmd = """
library(RPostgreSQL)
drv = dbDriver('PostgreSQL')
con = dbConnect(drv, dbname='%(db_name)s')
q = "%(query)s"
data = dbGetQuery(con, q)
"""
return GGData(cmd % {
'db_name': db,
'query': sql
}) | python | def data_sql(db, sql):
"""Load file using RPostgreSQL
Place to edit if want to add more database backend support
"""
if not db:
if sql:
print "ERR: -db option must be set if using -sql"
return ""
cmd = """
library(RPostgreSQL)
drv = dbDriver('PostgreSQL')
con = dbConnect(drv, dbname='%(db_name)s')
q = "%(query)s"
data = dbGetQuery(con, q)
"""
return GGData(cmd % {
'db_name': db,
'query': sql
}) | [
"def",
"data_sql",
"(",
"db",
",",
"sql",
")",
":",
"if",
"not",
"db",
":",
"if",
"sql",
":",
"print",
"\"ERR: -db option must be set if using -sql\"",
"return",
"\"\"",
"cmd",
"=",
"\"\"\"\n library(RPostgreSQL)\n drv = dbDriver('PostgreSQL')\n con = dbConnect(drv, dbname='%(db_name)s')\n q = \"%(query)s\"\n data = dbGetQuery(con, q)\n \"\"\"",
"return",
"GGData",
"(",
"cmd",
"%",
"{",
"'db_name'",
":",
"db",
",",
"'query'",
":",
"sql",
"}",
")"
] | Load file using RPostgreSQL
Place to edit if want to add more database backend support | [
"Load",
"file",
"using",
"RPostgreSQL"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L151-L173 |
sirrice/pygg | pygg/pygg.py | data_py | def data_py(o, *args, **kwargs):
"""converts python object into R Dataframe definition
converts following data structures:
row oriented list of dictionaries:
[ { 'x': 0, 'y': 1, ...}, ... ]
col oriented dictionary of lists
{ 'x': [0,1,2...], 'y': [...], ... }
@param o python object to convert
@param args argument list to pass to read.csv
@param kwargs keyword args to pass to read.csv
@return a tuple of the file containing the data and an
expression to define data.frame object and set it to variable "data"
data = read.csv(tmpfile, *args, **kwargs)
"""
if isinstance(o, basestring):
fname = o
else:
if not is_pandas_df(o):
# convert incoming data layout to pandas' DataFrame
o = pandas.DataFrame(o)
fname = tempfile.NamedTemporaryFile().name
o.to_csv(fname, sep=',', encoding='utf-8', index=False)
kwargs["sep"] = esc(',')
read_csv_stmt = GGStatement("read.csv", esc(fname), *args, **kwargs).r
return GGData("data = {}".format(read_csv_stmt), fname=fname) | python | def data_py(o, *args, **kwargs):
"""converts python object into R Dataframe definition
converts following data structures:
row oriented list of dictionaries:
[ { 'x': 0, 'y': 1, ...}, ... ]
col oriented dictionary of lists
{ 'x': [0,1,2...], 'y': [...], ... }
@param o python object to convert
@param args argument list to pass to read.csv
@param kwargs keyword args to pass to read.csv
@return a tuple of the file containing the data and an
expression to define data.frame object and set it to variable "data"
data = read.csv(tmpfile, *args, **kwargs)
"""
if isinstance(o, basestring):
fname = o
else:
if not is_pandas_df(o):
# convert incoming data layout to pandas' DataFrame
o = pandas.DataFrame(o)
fname = tempfile.NamedTemporaryFile().name
o.to_csv(fname, sep=',', encoding='utf-8', index=False)
kwargs["sep"] = esc(',')
read_csv_stmt = GGStatement("read.csv", esc(fname), *args, **kwargs).r
return GGData("data = {}".format(read_csv_stmt), fname=fname) | [
"def",
"data_py",
"(",
"o",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"o",
",",
"basestring",
")",
":",
"fname",
"=",
"o",
"else",
":",
"if",
"not",
"is_pandas_df",
"(",
"o",
")",
":",
"# convert incoming data layout to pandas' DataFrame",
"o",
"=",
"pandas",
".",
"DataFrame",
"(",
"o",
")",
"fname",
"=",
"tempfile",
".",
"NamedTemporaryFile",
"(",
")",
".",
"name",
"o",
".",
"to_csv",
"(",
"fname",
",",
"sep",
"=",
"','",
",",
"encoding",
"=",
"'utf-8'",
",",
"index",
"=",
"False",
")",
"kwargs",
"[",
"\"sep\"",
"]",
"=",
"esc",
"(",
"','",
")",
"read_csv_stmt",
"=",
"GGStatement",
"(",
"\"read.csv\"",
",",
"esc",
"(",
"fname",
")",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
".",
"r",
"return",
"GGData",
"(",
"\"data = {}\"",
".",
"format",
"(",
"read_csv_stmt",
")",
",",
"fname",
"=",
"fname",
")"
] | converts python object into R Dataframe definition
converts following data structures:
row oriented list of dictionaries:
[ { 'x': 0, 'y': 1, ...}, ... ]
col oriented dictionary of lists
{ 'x': [0,1,2...], 'y': [...], ... }
@param o python object to convert
@param args argument list to pass to read.csv
@param kwargs keyword args to pass to read.csv
@return a tuple of the file containing the data and an
expression to define data.frame object and set it to variable "data"
data = read.csv(tmpfile, *args, **kwargs) | [
"converts",
"python",
"object",
"into",
"R",
"Dataframe",
"definition"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L176-L208 |
sirrice/pygg | pygg/pygg.py | ggsave | def ggsave(name, plot, data=None, *args, **kwargs):
"""Save a GGStatements object to destination name
@param name output file name. if None, don't run R command
@param kwargs keyword args to pass to ggsave. The following are special
keywords for the python save method
data: a python data object (list, dict, DataFrame) used to populate
the `data` variable in R
libs: list of library names to load in addition to ggplot2
prefix: string containing R code to run before any ggplot commands (including data loading)
postfix: string containing R code to run after data is loaded (e.g., if you want to rename variable names)
quiet: if Truthy, don't print out R program string
"""
# constants
kwdefaults = {
'width': 10,
'height': 8,
'scale': 1
}
keys_to_rm = ["prefix", "quiet", "postfix", 'libs']
varname = 'p'
# process arguments
prefix = kwargs.get('prefix', '')
postfix = kwargs.get('postfix', '')
libs = kwargs.get('libs', [])
libs = '\n'.join(["library(%s)" % lib for lib in libs])
quiet = kwargs.get("quiet", False)
kwargs = {k: v for k, v in kwargs.iteritems()
if v is not None and k not in keys_to_rm}
kwdefaults.update(kwargs)
kwargs = kwdefaults
# figure out how to load data in the R environment
if data is None: data = plot.data
if data is None:
# Don't load anything, the data source is already present in R
data_src = ''
elif isinstance(data, basestring) and 'RPostgreSQL' in data:
# Hack to allow through data_sql results
data_src = data
elif isinstance(data, GGData):
data_src = str(data)
else:
# format the python data object
data_src = str(data_py(data))
prog = "%(header)s\n%(libs)s\n%(prefix)s\n%(data)s\n%(postfix)s\n%(varname)s = %(prog)s" % {
'header': "library(ggplot2)",
'libs': libs,
'data': data_src,
'prefix': prefix,
'postfix': postfix,
'varname': varname,
'prog': plot.r
}
if name:
stmt = GGStatement("ggsave", esc(name), varname, *args, **kwargs)
prog = "%s\n%s" % (prog, stmt.r)
if not quiet:
print prog
print
if name:
execute_r(prog, quiet)
return prog | python | def ggsave(name, plot, data=None, *args, **kwargs):
"""Save a GGStatements object to destination name
@param name output file name. if None, don't run R command
@param kwargs keyword args to pass to ggsave. The following are special
keywords for the python save method
data: a python data object (list, dict, DataFrame) used to populate
the `data` variable in R
libs: list of library names to load in addition to ggplot2
prefix: string containing R code to run before any ggplot commands (including data loading)
postfix: string containing R code to run after data is loaded (e.g., if you want to rename variable names)
quiet: if Truthy, don't print out R program string
"""
# constants
kwdefaults = {
'width': 10,
'height': 8,
'scale': 1
}
keys_to_rm = ["prefix", "quiet", "postfix", 'libs']
varname = 'p'
# process arguments
prefix = kwargs.get('prefix', '')
postfix = kwargs.get('postfix', '')
libs = kwargs.get('libs', [])
libs = '\n'.join(["library(%s)" % lib for lib in libs])
quiet = kwargs.get("quiet", False)
kwargs = {k: v for k, v in kwargs.iteritems()
if v is not None and k not in keys_to_rm}
kwdefaults.update(kwargs)
kwargs = kwdefaults
# figure out how to load data in the R environment
if data is None: data = plot.data
if data is None:
# Don't load anything, the data source is already present in R
data_src = ''
elif isinstance(data, basestring) and 'RPostgreSQL' in data:
# Hack to allow through data_sql results
data_src = data
elif isinstance(data, GGData):
data_src = str(data)
else:
# format the python data object
data_src = str(data_py(data))
prog = "%(header)s\n%(libs)s\n%(prefix)s\n%(data)s\n%(postfix)s\n%(varname)s = %(prog)s" % {
'header': "library(ggplot2)",
'libs': libs,
'data': data_src,
'prefix': prefix,
'postfix': postfix,
'varname': varname,
'prog': plot.r
}
if name:
stmt = GGStatement("ggsave", esc(name), varname, *args, **kwargs)
prog = "%s\n%s" % (prog, stmt.r)
if not quiet:
print prog
print
if name:
execute_r(prog, quiet)
return prog | [
"def",
"ggsave",
"(",
"name",
",",
"plot",
",",
"data",
"=",
"None",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# constants",
"kwdefaults",
"=",
"{",
"'width'",
":",
"10",
",",
"'height'",
":",
"8",
",",
"'scale'",
":",
"1",
"}",
"keys_to_rm",
"=",
"[",
"\"prefix\"",
",",
"\"quiet\"",
",",
"\"postfix\"",
",",
"'libs'",
"]",
"varname",
"=",
"'p'",
"# process arguments",
"prefix",
"=",
"kwargs",
".",
"get",
"(",
"'prefix'",
",",
"''",
")",
"postfix",
"=",
"kwargs",
".",
"get",
"(",
"'postfix'",
",",
"''",
")",
"libs",
"=",
"kwargs",
".",
"get",
"(",
"'libs'",
",",
"[",
"]",
")",
"libs",
"=",
"'\\n'",
".",
"join",
"(",
"[",
"\"library(%s)\"",
"%",
"lib",
"for",
"lib",
"in",
"libs",
"]",
")",
"quiet",
"=",
"kwargs",
".",
"get",
"(",
"\"quiet\"",
",",
"False",
")",
"kwargs",
"=",
"{",
"k",
":",
"v",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"iteritems",
"(",
")",
"if",
"v",
"is",
"not",
"None",
"and",
"k",
"not",
"in",
"keys_to_rm",
"}",
"kwdefaults",
".",
"update",
"(",
"kwargs",
")",
"kwargs",
"=",
"kwdefaults",
"# figure out how to load data in the R environment",
"if",
"data",
"is",
"None",
":",
"data",
"=",
"plot",
".",
"data",
"if",
"data",
"is",
"None",
":",
"# Don't load anything, the data source is already present in R",
"data_src",
"=",
"''",
"elif",
"isinstance",
"(",
"data",
",",
"basestring",
")",
"and",
"'RPostgreSQL'",
"in",
"data",
":",
"# Hack to allow through data_sql results",
"data_src",
"=",
"data",
"elif",
"isinstance",
"(",
"data",
",",
"GGData",
")",
":",
"data_src",
"=",
"str",
"(",
"data",
")",
"else",
":",
"# format the python data object",
"data_src",
"=",
"str",
"(",
"data_py",
"(",
"data",
")",
")",
"prog",
"=",
"\"%(header)s\\n%(libs)s\\n%(prefix)s\\n%(data)s\\n%(postfix)s\\n%(varname)s = %(prog)s\"",
"%",
"{",
"'header'",
":",
"\"library(ggplot2)\"",
",",
"'libs'",
":",
"libs",
",",
"'data'",
":",
"data_src",
",",
"'prefix'",
":",
"prefix",
",",
"'postfix'",
":",
"postfix",
",",
"'varname'",
":",
"varname",
",",
"'prog'",
":",
"plot",
".",
"r",
"}",
"if",
"name",
":",
"stmt",
"=",
"GGStatement",
"(",
"\"ggsave\"",
",",
"esc",
"(",
"name",
")",
",",
"varname",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"prog",
"=",
"\"%s\\n%s\"",
"%",
"(",
"prog",
",",
"stmt",
".",
"r",
")",
"if",
"not",
"quiet",
":",
"print",
"prog",
"print",
"if",
"name",
":",
"execute_r",
"(",
"prog",
",",
"quiet",
")",
"return",
"prog"
] | Save a GGStatements object to destination name
@param name output file name. if None, don't run R command
@param kwargs keyword args to pass to ggsave. The following are special
keywords for the python save method
data: a python data object (list, dict, DataFrame) used to populate
the `data` variable in R
libs: list of library names to load in addition to ggplot2
prefix: string containing R code to run before any ggplot commands (including data loading)
postfix: string containing R code to run after data is loaded (e.g., if you want to rename variable names)
quiet: if Truthy, don't print out R program string | [
"Save",
"a",
"GGStatements",
"object",
"to",
"destination",
"name"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L245-L315 |
sirrice/pygg | pygg/pygg.py | gg_ipython | def gg_ipython(plot, data, width=IPYTHON_IMAGE_SIZE, height=None,
*args, **kwargs):
"""Render pygg in an IPython notebook
Allows one to say things like:
import pygg
p = pygg.ggplot('diamonds', pygg.aes(x='carat', y='price', color='clarity'))
p += pygg.geom_point(alpha=0.5, size = 2)
p += pygg.scale_x_log10(limits=[1, 2])
pygg.gg_ipython(p, data=None, quiet=True)
directly in an IPython notebook and see the resulting ggplot2 image
displayed inline. This function is print a warning if the IPython library
cannot be imported. The ggplot2 image is rendered as a PNG and not
as a vectorized graphics object right now.
Note that by default gg_ipython sets the output height and width to
IPYTHON_IMAGE_SIZE pixels as this is a reasonable default size for a
browser-based notebook. Height is by default None, indicating that height
should be set to the same value as width. It is possible to adjust
the aspect ratio of the output by providing non-None values for both
width and height
"""
try:
import IPython.display
tmp_image_filename = tempfile.NamedTemporaryFile(suffix='.jpg').name
# Quiet by default
kwargs['quiet'] = kwargs.get('quiet', True)
if width is None:
raise ValueError("Width cannot be None")
height = height or width
w_in, h_in = size_r_img_inches(width, height)
ggsave(name=tmp_image_filename, plot=plot, data=data,
dpi=600, width=w_in, height=h_in, units=esc('in'),
*args, **kwargs)
return IPython.display.Image(filename=tmp_image_filename,
width=width, height=height)
except ImportError:
print "Could't load IPython library; integration is disabled" | python | def gg_ipython(plot, data, width=IPYTHON_IMAGE_SIZE, height=None,
*args, **kwargs):
"""Render pygg in an IPython notebook
Allows one to say things like:
import pygg
p = pygg.ggplot('diamonds', pygg.aes(x='carat', y='price', color='clarity'))
p += pygg.geom_point(alpha=0.5, size = 2)
p += pygg.scale_x_log10(limits=[1, 2])
pygg.gg_ipython(p, data=None, quiet=True)
directly in an IPython notebook and see the resulting ggplot2 image
displayed inline. This function is print a warning if the IPython library
cannot be imported. The ggplot2 image is rendered as a PNG and not
as a vectorized graphics object right now.
Note that by default gg_ipython sets the output height and width to
IPYTHON_IMAGE_SIZE pixels as this is a reasonable default size for a
browser-based notebook. Height is by default None, indicating that height
should be set to the same value as width. It is possible to adjust
the aspect ratio of the output by providing non-None values for both
width and height
"""
try:
import IPython.display
tmp_image_filename = tempfile.NamedTemporaryFile(suffix='.jpg').name
# Quiet by default
kwargs['quiet'] = kwargs.get('quiet', True)
if width is None:
raise ValueError("Width cannot be None")
height = height or width
w_in, h_in = size_r_img_inches(width, height)
ggsave(name=tmp_image_filename, plot=plot, data=data,
dpi=600, width=w_in, height=h_in, units=esc('in'),
*args, **kwargs)
return IPython.display.Image(filename=tmp_image_filename,
width=width, height=height)
except ImportError:
print "Could't load IPython library; integration is disabled" | [
"def",
"gg_ipython",
"(",
"plot",
",",
"data",
",",
"width",
"=",
"IPYTHON_IMAGE_SIZE",
",",
"height",
"=",
"None",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"try",
":",
"import",
"IPython",
".",
"display",
"tmp_image_filename",
"=",
"tempfile",
".",
"NamedTemporaryFile",
"(",
"suffix",
"=",
"'.jpg'",
")",
".",
"name",
"# Quiet by default",
"kwargs",
"[",
"'quiet'",
"]",
"=",
"kwargs",
".",
"get",
"(",
"'quiet'",
",",
"True",
")",
"if",
"width",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"Width cannot be None\"",
")",
"height",
"=",
"height",
"or",
"width",
"w_in",
",",
"h_in",
"=",
"size_r_img_inches",
"(",
"width",
",",
"height",
")",
"ggsave",
"(",
"name",
"=",
"tmp_image_filename",
",",
"plot",
"=",
"plot",
",",
"data",
"=",
"data",
",",
"dpi",
"=",
"600",
",",
"width",
"=",
"w_in",
",",
"height",
"=",
"h_in",
",",
"units",
"=",
"esc",
"(",
"'in'",
")",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"return",
"IPython",
".",
"display",
".",
"Image",
"(",
"filename",
"=",
"tmp_image_filename",
",",
"width",
"=",
"width",
",",
"height",
"=",
"height",
")",
"except",
"ImportError",
":",
"print",
"\"Could't load IPython library; integration is disabled\""
] | Render pygg in an IPython notebook
Allows one to say things like:
import pygg
p = pygg.ggplot('diamonds', pygg.aes(x='carat', y='price', color='clarity'))
p += pygg.geom_point(alpha=0.5, size = 2)
p += pygg.scale_x_log10(limits=[1, 2])
pygg.gg_ipython(p, data=None, quiet=True)
directly in an IPython notebook and see the resulting ggplot2 image
displayed inline. This function is print a warning if the IPython library
cannot be imported. The ggplot2 image is rendered as a PNG and not
as a vectorized graphics object right now.
Note that by default gg_ipython sets the output height and width to
IPYTHON_IMAGE_SIZE pixels as this is a reasonable default size for a
browser-based notebook. Height is by default None, indicating that height
should be set to the same value as width. It is possible to adjust
the aspect ratio of the output by providing non-None values for both
width and height | [
"Render",
"pygg",
"in",
"an",
"IPython",
"notebook"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L318-L359 |
sirrice/pygg | pygg/pygg.py | size_r_img_inches | def size_r_img_inches(width, height):
"""Compute the width and height for an R image for display in IPython
Neight width nor height can be null but should be integer pixel values > 0.
Returns a tuple of (width, height) that should be used by ggsave in R to
produce an appropriately sized jpeg/png/pdf image with the right aspect
ratio. The returned values are in inches.
"""
# both width and height are given
aspect_ratio = height / (1.0 * width)
return R_IMAGE_SIZE, round(aspect_ratio * R_IMAGE_SIZE, 2) | python | def size_r_img_inches(width, height):
"""Compute the width and height for an R image for display in IPython
Neight width nor height can be null but should be integer pixel values > 0.
Returns a tuple of (width, height) that should be used by ggsave in R to
produce an appropriately sized jpeg/png/pdf image with the right aspect
ratio. The returned values are in inches.
"""
# both width and height are given
aspect_ratio = height / (1.0 * width)
return R_IMAGE_SIZE, round(aspect_ratio * R_IMAGE_SIZE, 2) | [
"def",
"size_r_img_inches",
"(",
"width",
",",
"height",
")",
":",
"# both width and height are given",
"aspect_ratio",
"=",
"height",
"/",
"(",
"1.0",
"*",
"width",
")",
"return",
"R_IMAGE_SIZE",
",",
"round",
"(",
"aspect_ratio",
"*",
"R_IMAGE_SIZE",
",",
"2",
")"
] | Compute the width and height for an R image for display in IPython
Neight width nor height can be null but should be integer pixel values > 0.
Returns a tuple of (width, height) that should be used by ggsave in R to
produce an appropriately sized jpeg/png/pdf image with the right aspect
ratio. The returned values are in inches. | [
"Compute",
"the",
"width",
"and",
"height",
"for",
"an",
"R",
"image",
"for",
"display",
"in",
"IPython"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L362-L374 |
sirrice/pygg | pygg/pygg.py | execute_r | def execute_r(prog, quiet):
"""Run the R code prog an R subprocess
@raises ValueError if the subprocess exits with non-zero status
"""
FNULL = open(os.devnull, 'w') if quiet else None
try:
input_proc = subprocess.Popen(["echo", prog], stdout=subprocess.PIPE)
status = subprocess.call("R --no-save --quiet",
stdin=input_proc.stdout,
stdout=FNULL,
stderr=subprocess.STDOUT,
shell=True) # warning, this is a security problem
if status != 0:
raise ValueError("ggplot2 bridge failed for program: {}."
" Check for an error".format(prog))
finally:
if FNULL is not None:
FNULL.close() | python | def execute_r(prog, quiet):
"""Run the R code prog an R subprocess
@raises ValueError if the subprocess exits with non-zero status
"""
FNULL = open(os.devnull, 'w') if quiet else None
try:
input_proc = subprocess.Popen(["echo", prog], stdout=subprocess.PIPE)
status = subprocess.call("R --no-save --quiet",
stdin=input_proc.stdout,
stdout=FNULL,
stderr=subprocess.STDOUT,
shell=True) # warning, this is a security problem
if status != 0:
raise ValueError("ggplot2 bridge failed for program: {}."
" Check for an error".format(prog))
finally:
if FNULL is not None:
FNULL.close() | [
"def",
"execute_r",
"(",
"prog",
",",
"quiet",
")",
":",
"FNULL",
"=",
"open",
"(",
"os",
".",
"devnull",
",",
"'w'",
")",
"if",
"quiet",
"else",
"None",
"try",
":",
"input_proc",
"=",
"subprocess",
".",
"Popen",
"(",
"[",
"\"echo\"",
",",
"prog",
"]",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
")",
"status",
"=",
"subprocess",
".",
"call",
"(",
"\"R --no-save --quiet\"",
",",
"stdin",
"=",
"input_proc",
".",
"stdout",
",",
"stdout",
"=",
"FNULL",
",",
"stderr",
"=",
"subprocess",
".",
"STDOUT",
",",
"shell",
"=",
"True",
")",
"# warning, this is a security problem",
"if",
"status",
"!=",
"0",
":",
"raise",
"ValueError",
"(",
"\"ggplot2 bridge failed for program: {}.\"",
"\" Check for an error\"",
".",
"format",
"(",
"prog",
")",
")",
"finally",
":",
"if",
"FNULL",
"is",
"not",
"None",
":",
"FNULL",
".",
"close",
"(",
")"
] | Run the R code prog an R subprocess
@raises ValueError if the subprocess exits with non-zero status | [
"Run",
"the",
"R",
"code",
"prog",
"an",
"R",
"subprocess"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L377-L395 |
sirrice/pygg | pygg/pygg.py | axis_labels | def axis_labels(xtitle,
ytitle,
xsuffix="continuous",
ysuffix="continuous",
xkwargs={},
ykwargs={}):
"""
Helper function to create reasonable axis labels
@param xtitle String for the title of the X axis. Automatically escaped
@param ytitle String for the title of the Y axis. Automatically escaped
@param xsuffix Suffix string appended to "scales_x_" to define the type of x axis
Default: "continuous"
@param ysuffix Suffix string appended to "scales_y_" to define the type of y axis
Default: "continuous"
@param xkwargs keyword arguments to pass to scales_x_* function
@param xkwargs keyword arguments to pass to scales_x_* function
@return GGStatements
For example:
p = ggplot(...)
p += axis_labels("Dataset Size (MB)",
"Latency (sec)",
"log10",
xkwargs=dict(breaks=[0, 10, 100, 5000]))
"""
exec "xfunc = scale_x_%s" % xsuffix
exec "yfunc = scale_y_%s" % ysuffix
return (
xfunc(name=esc(xtitle), **xkwargs) +
yfunc(name=esc(ytitle), **ykwargs)
) | python | def axis_labels(xtitle,
ytitle,
xsuffix="continuous",
ysuffix="continuous",
xkwargs={},
ykwargs={}):
"""
Helper function to create reasonable axis labels
@param xtitle String for the title of the X axis. Automatically escaped
@param ytitle String for the title of the Y axis. Automatically escaped
@param xsuffix Suffix string appended to "scales_x_" to define the type of x axis
Default: "continuous"
@param ysuffix Suffix string appended to "scales_y_" to define the type of y axis
Default: "continuous"
@param xkwargs keyword arguments to pass to scales_x_* function
@param xkwargs keyword arguments to pass to scales_x_* function
@return GGStatements
For example:
p = ggplot(...)
p += axis_labels("Dataset Size (MB)",
"Latency (sec)",
"log10",
xkwargs=dict(breaks=[0, 10, 100, 5000]))
"""
exec "xfunc = scale_x_%s" % xsuffix
exec "yfunc = scale_y_%s" % ysuffix
return (
xfunc(name=esc(xtitle), **xkwargs) +
yfunc(name=esc(ytitle), **ykwargs)
) | [
"def",
"axis_labels",
"(",
"xtitle",
",",
"ytitle",
",",
"xsuffix",
"=",
"\"continuous\"",
",",
"ysuffix",
"=",
"\"continuous\"",
",",
"xkwargs",
"=",
"{",
"}",
",",
"ykwargs",
"=",
"{",
"}",
")",
":",
"exec",
"\"xfunc = scale_x_%s\"",
"%",
"xsuffix",
"exec",
"\"yfunc = scale_y_%s\"",
"%",
"ysuffix",
"return",
"(",
"xfunc",
"(",
"name",
"=",
"esc",
"(",
"xtitle",
")",
",",
"*",
"*",
"xkwargs",
")",
"+",
"yfunc",
"(",
"name",
"=",
"esc",
"(",
"ytitle",
")",
",",
"*",
"*",
"ykwargs",
")",
")"
] | Helper function to create reasonable axis labels
@param xtitle String for the title of the X axis. Automatically escaped
@param ytitle String for the title of the Y axis. Automatically escaped
@param xsuffix Suffix string appended to "scales_x_" to define the type of x axis
Default: "continuous"
@param ysuffix Suffix string appended to "scales_y_" to define the type of y axis
Default: "continuous"
@param xkwargs keyword arguments to pass to scales_x_* function
@param xkwargs keyword arguments to pass to scales_x_* function
@return GGStatements
For example:
p = ggplot(...)
p += axis_labels("Dataset Size (MB)",
"Latency (sec)",
"log10",
xkwargs=dict(breaks=[0, 10, 100, 5000])) | [
"Helper",
"function",
"to",
"create",
"reasonable",
"axis",
"labels"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L403-L437 |
sirrice/pygg | pygg/pygg.py | make_master_binding | def make_master_binding():
"""
wrap around ggplot() call to handle passed in data objects
"""
ggplot = make_ggplot2_binding("ggplot")
def _ggplot(data, *args, **kwargs):
data_var = data
if not isinstance(data, basestring):
data_var = "data"
else:
data = None
stmt = ggplot(data_var, *args, **kwargs)
stmt.data = data
return stmt
return _ggplot | python | def make_master_binding():
"""
wrap around ggplot() call to handle passed in data objects
"""
ggplot = make_ggplot2_binding("ggplot")
def _ggplot(data, *args, **kwargs):
data_var = data
if not isinstance(data, basestring):
data_var = "data"
else:
data = None
stmt = ggplot(data_var, *args, **kwargs)
stmt.data = data
return stmt
return _ggplot | [
"def",
"make_master_binding",
"(",
")",
":",
"ggplot",
"=",
"make_ggplot2_binding",
"(",
"\"ggplot\"",
")",
"def",
"_ggplot",
"(",
"data",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"data_var",
"=",
"data",
"if",
"not",
"isinstance",
"(",
"data",
",",
"basestring",
")",
":",
"data_var",
"=",
"\"data\"",
"else",
":",
"data",
"=",
"None",
"stmt",
"=",
"ggplot",
"(",
"data_var",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"stmt",
".",
"data",
"=",
"data",
"return",
"stmt",
"return",
"_ggplot"
] | wrap around ggplot() call to handle passed in data objects | [
"wrap",
"around",
"ggplot",
"()",
"call",
"to",
"handle",
"passed",
"in",
"data",
"objects"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L448-L462 |
sirrice/pygg | pygg/pygg.py | GGStatement.r | def r(self):
"""Convert this GGStatement into its R equivalent expression"""
r_args = [_to_r(self.args), _to_r(self.kwargs)]
# remove empty strings from the call args
r_args = ",".join([x for x in r_args if x != ""])
return "{}({})".format(self.name, r_args) | python | def r(self):
"""Convert this GGStatement into its R equivalent expression"""
r_args = [_to_r(self.args), _to_r(self.kwargs)]
# remove empty strings from the call args
r_args = ",".join([x for x in r_args if x != ""])
return "{}({})".format(self.name, r_args) | [
"def",
"r",
"(",
"self",
")",
":",
"r_args",
"=",
"[",
"_to_r",
"(",
"self",
".",
"args",
")",
",",
"_to_r",
"(",
"self",
".",
"kwargs",
")",
"]",
"# remove empty strings from the call args",
"r_args",
"=",
"\",\"",
".",
"join",
"(",
"[",
"x",
"for",
"x",
"in",
"r_args",
"if",
"x",
"!=",
"\"\"",
"]",
")",
"return",
"\"{}({})\"",
".",
"format",
"(",
"self",
".",
"name",
",",
"r_args",
")"
] | Convert this GGStatement into its R equivalent expression | [
"Convert",
"this",
"GGStatement",
"into",
"its",
"R",
"equivalent",
"expression"
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/pygg/pygg.py#L74-L79 |
sirrice/pygg | bin/runpygg.py | main | def main(c, prefix, csv, db, sql, o, w, h, scale):
"""
ggplot2 syntax in Python.
Run pygg command from command line
python pygg -c "ggplot('diamonds', aes('carat', 'price')) + geom_point()"
Import into your python program to use ggplot
\b
from pygg import *
p = ggplot('diamonds', aes('carat', y='price')) + geom_point()
p = p + facet_wrap(None, "color")
\b
# prefix argument is a string to execute before running ggplot and ggsave commands
prefix = \"\"\"diamonds = ...R code to load data... \"\"\"
ggsave("test.pdf", p, prefix=prefix)
# the following is a shorthand
p.save("test.pdf", prefix=prefix)
Use convenience, ggsave() takes a data=... keyword argument for common data objects
\b
# load from database query
ggsave(..., data = data_sql('DBNAME', 'SELECT * FROM T'))
\b
# load from CSV file. Takse same arguments as R's read.csv
ggsave(..., data = "FILENAME.csv")
# or, to control the seperator :
ggsave(..., prefix = data_csv("FILENAME", sep=','))
\b
# load column or row oriented python object. Run help(data_py) for more details
ggsave(..., data = {'x': [0,1,2], 'y': [9,8,7]})
ggsave(..., data = [{'x': 0, 'y': 1}, {'x': 2, 'y': 3}])
\b
df = ...pandas DataFrame object...
ggsave(..., data = df)
Example commands
\b
python runpygg -db database -sql "SELECT 1 as x, 2 as y" -c "ggplot('data', aes('x', 'y')) + geom_point()" -o test.pdf
python runpygg -csv mydata.csv -c "ggplot('data', aes(x='attr1', y='attr2')) + geom_point()"
Caveats: Does not copy and import data between python and R, so pygg only works for SQL or CSV file inputs
"""
if not c:
print "no command. exiting"
return
kwargs = {
'width': w,
'height': h,
'scale': scale,
'prefix': '\n'.join(filter(bool, [prefix]))
}
if csv:
kwargs['data'] = csv
else:
kwargs['data'] = data_sql(db, sql)
c = "plot = %s" % c
if o:
exec c
plot.save(o, **kwargs)
else:
print c | python | def main(c, prefix, csv, db, sql, o, w, h, scale):
"""
ggplot2 syntax in Python.
Run pygg command from command line
python pygg -c "ggplot('diamonds', aes('carat', 'price')) + geom_point()"
Import into your python program to use ggplot
\b
from pygg import *
p = ggplot('diamonds', aes('carat', y='price')) + geom_point()
p = p + facet_wrap(None, "color")
\b
# prefix argument is a string to execute before running ggplot and ggsave commands
prefix = \"\"\"diamonds = ...R code to load data... \"\"\"
ggsave("test.pdf", p, prefix=prefix)
# the following is a shorthand
p.save("test.pdf", prefix=prefix)
Use convenience, ggsave() takes a data=... keyword argument for common data objects
\b
# load from database query
ggsave(..., data = data_sql('DBNAME', 'SELECT * FROM T'))
\b
# load from CSV file. Takse same arguments as R's read.csv
ggsave(..., data = "FILENAME.csv")
# or, to control the seperator :
ggsave(..., prefix = data_csv("FILENAME", sep=','))
\b
# load column or row oriented python object. Run help(data_py) for more details
ggsave(..., data = {'x': [0,1,2], 'y': [9,8,7]})
ggsave(..., data = [{'x': 0, 'y': 1}, {'x': 2, 'y': 3}])
\b
df = ...pandas DataFrame object...
ggsave(..., data = df)
Example commands
\b
python runpygg -db database -sql "SELECT 1 as x, 2 as y" -c "ggplot('data', aes('x', 'y')) + geom_point()" -o test.pdf
python runpygg -csv mydata.csv -c "ggplot('data', aes(x='attr1', y='attr2')) + geom_point()"
Caveats: Does not copy and import data between python and R, so pygg only works for SQL or CSV file inputs
"""
if not c:
print "no command. exiting"
return
kwargs = {
'width': w,
'height': h,
'scale': scale,
'prefix': '\n'.join(filter(bool, [prefix]))
}
if csv:
kwargs['data'] = csv
else:
kwargs['data'] = data_sql(db, sql)
c = "plot = %s" % c
if o:
exec c
plot.save(o, **kwargs)
else:
print c | [
"def",
"main",
"(",
"c",
",",
"prefix",
",",
"csv",
",",
"db",
",",
"sql",
",",
"o",
",",
"w",
",",
"h",
",",
"scale",
")",
":",
"if",
"not",
"c",
":",
"print",
"\"no command. exiting\"",
"return",
"kwargs",
"=",
"{",
"'width'",
":",
"w",
",",
"'height'",
":",
"h",
",",
"'scale'",
":",
"scale",
",",
"'prefix'",
":",
"'\\n'",
".",
"join",
"(",
"filter",
"(",
"bool",
",",
"[",
"prefix",
"]",
")",
")",
"}",
"if",
"csv",
":",
"kwargs",
"[",
"'data'",
"]",
"=",
"csv",
"else",
":",
"kwargs",
"[",
"'data'",
"]",
"=",
"data_sql",
"(",
"db",
",",
"sql",
")",
"c",
"=",
"\"plot = %s\"",
"%",
"c",
"if",
"o",
":",
"exec",
"c",
"plot",
".",
"save",
"(",
"o",
",",
"*",
"*",
"kwargs",
")",
"else",
":",
"print",
"c"
] | ggplot2 syntax in Python.
Run pygg command from command line
python pygg -c "ggplot('diamonds', aes('carat', 'price')) + geom_point()"
Import into your python program to use ggplot
\b
from pygg import *
p = ggplot('diamonds', aes('carat', y='price')) + geom_point()
p = p + facet_wrap(None, "color")
\b
# prefix argument is a string to execute before running ggplot and ggsave commands
prefix = \"\"\"diamonds = ...R code to load data... \"\"\"
ggsave("test.pdf", p, prefix=prefix)
# the following is a shorthand
p.save("test.pdf", prefix=prefix)
Use convenience, ggsave() takes a data=... keyword argument for common data objects
\b
# load from database query
ggsave(..., data = data_sql('DBNAME', 'SELECT * FROM T'))
\b
# load from CSV file. Takse same arguments as R's read.csv
ggsave(..., data = "FILENAME.csv")
# or, to control the seperator :
ggsave(..., prefix = data_csv("FILENAME", sep=','))
\b
# load column or row oriented python object. Run help(data_py) for more details
ggsave(..., data = {'x': [0,1,2], 'y': [9,8,7]})
ggsave(..., data = [{'x': 0, 'y': 1}, {'x': 2, 'y': 3}])
\b
df = ...pandas DataFrame object...
ggsave(..., data = df)
Example commands
\b
python runpygg -db database -sql "SELECT 1 as x, 2 as y" -c "ggplot('data', aes('x', 'y')) + geom_point()" -o test.pdf
python runpygg -csv mydata.csv -c "ggplot('data', aes(x='attr1', y='attr2')) + geom_point()"
Caveats: Does not copy and import data between python and R, so pygg only works for SQL or CSV file inputs | [
"ggplot2",
"syntax",
"in",
"Python",
"."
] | train | https://github.com/sirrice/pygg/blob/b36e19b3827e0a7d661de660b04d55a73f35896b/bin/runpygg.py#L24-L100 |
pygeobuf/pygeobuf | geobuf/scripts/cli.py | encode | def encode(precision, with_z):
"""Given GeoJSON on stdin, writes a geobuf file to stdout."""
logger = logging.getLogger('geobuf')
stdin = click.get_text_stream('stdin')
sink = click.get_binary_stream('stdout')
try:
data = json.load(stdin)
pbf = geobuf.encode(
data,
precision if precision >= 0 else 6,
3 if with_z else 2)
sink.write(pbf)
sys.exit(0)
except Exception:
logger.exception("Failed. Exception caught")
sys.exit(1) | python | def encode(precision, with_z):
"""Given GeoJSON on stdin, writes a geobuf file to stdout."""
logger = logging.getLogger('geobuf')
stdin = click.get_text_stream('stdin')
sink = click.get_binary_stream('stdout')
try:
data = json.load(stdin)
pbf = geobuf.encode(
data,
precision if precision >= 0 else 6,
3 if with_z else 2)
sink.write(pbf)
sys.exit(0)
except Exception:
logger.exception("Failed. Exception caught")
sys.exit(1) | [
"def",
"encode",
"(",
"precision",
",",
"with_z",
")",
":",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"'geobuf'",
")",
"stdin",
"=",
"click",
".",
"get_text_stream",
"(",
"'stdin'",
")",
"sink",
"=",
"click",
".",
"get_binary_stream",
"(",
"'stdout'",
")",
"try",
":",
"data",
"=",
"json",
".",
"load",
"(",
"stdin",
")",
"pbf",
"=",
"geobuf",
".",
"encode",
"(",
"data",
",",
"precision",
"if",
"precision",
">=",
"0",
"else",
"6",
",",
"3",
"if",
"with_z",
"else",
"2",
")",
"sink",
".",
"write",
"(",
"pbf",
")",
"sys",
".",
"exit",
"(",
"0",
")",
"except",
"Exception",
":",
"logger",
".",
"exception",
"(",
"\"Failed. Exception caught\"",
")",
"sys",
".",
"exit",
"(",
"1",
")"
] | Given GeoJSON on stdin, writes a geobuf file to stdout. | [
"Given",
"GeoJSON",
"on",
"stdin",
"writes",
"a",
"geobuf",
"file",
"to",
"stdout",
"."
] | train | https://github.com/pygeobuf/pygeobuf/blob/c9e055ab47532781626cfe2c931a8444820acf05/geobuf/scripts/cli.py#L46-L61 |
pygeobuf/pygeobuf | geobuf/scripts/cli.py | decode | def decode():
"""Given a Geobuf byte string on stdin, write a GeoJSON feature
collection to stdout."""
logger = logging.getLogger('geobuf')
stdin = click.get_binary_stream('stdin')
sink = click.get_text_stream('stdout')
try:
pbf = stdin.read()
data = geobuf.decode(pbf)
json.dump(data, sink)
sys.exit(0)
except Exception:
logger.exception("Failed. Exception caught")
sys.exit(1) | python | def decode():
"""Given a Geobuf byte string on stdin, write a GeoJSON feature
collection to stdout."""
logger = logging.getLogger('geobuf')
stdin = click.get_binary_stream('stdin')
sink = click.get_text_stream('stdout')
try:
pbf = stdin.read()
data = geobuf.decode(pbf)
json.dump(data, sink)
sys.exit(0)
except Exception:
logger.exception("Failed. Exception caught")
sys.exit(1) | [
"def",
"decode",
"(",
")",
":",
"logger",
"=",
"logging",
".",
"getLogger",
"(",
"'geobuf'",
")",
"stdin",
"=",
"click",
".",
"get_binary_stream",
"(",
"'stdin'",
")",
"sink",
"=",
"click",
".",
"get_text_stream",
"(",
"'stdout'",
")",
"try",
":",
"pbf",
"=",
"stdin",
".",
"read",
"(",
")",
"data",
"=",
"geobuf",
".",
"decode",
"(",
"pbf",
")",
"json",
".",
"dump",
"(",
"data",
",",
"sink",
")",
"sys",
".",
"exit",
"(",
"0",
")",
"except",
"Exception",
":",
"logger",
".",
"exception",
"(",
"\"Failed. Exception caught\"",
")",
"sys",
".",
"exit",
"(",
"1",
")"
] | Given a Geobuf byte string on stdin, write a GeoJSON feature
collection to stdout. | [
"Given",
"a",
"Geobuf",
"byte",
"string",
"on",
"stdin",
"write",
"a",
"GeoJSON",
"feature",
"collection",
"to",
"stdout",
"."
] | train | https://github.com/pygeobuf/pygeobuf/blob/c9e055ab47532781626cfe2c931a8444820acf05/geobuf/scripts/cli.py#L65-L78 |
tammoippen/geohash-hilbert | geohash_hilbert/_int2str.py | encode_int | def encode_int(code, bits_per_char=6):
"""Encode int into a string preserving order
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
code: int Positive integer.
bits_per_char: int The number of bits per coding character.
Returns:
str: the encoded integer
"""
if code < 0:
raise ValueError('Only positive ints are allowed!')
if bits_per_char == 6:
return _encode_int64(code)
if bits_per_char == 4:
return _encode_int16(code)
if bits_per_char == 2:
return _encode_int4(code)
raise ValueError('`bits_per_char` must be in {6, 4, 2}') | python | def encode_int(code, bits_per_char=6):
"""Encode int into a string preserving order
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
code: int Positive integer.
bits_per_char: int The number of bits per coding character.
Returns:
str: the encoded integer
"""
if code < 0:
raise ValueError('Only positive ints are allowed!')
if bits_per_char == 6:
return _encode_int64(code)
if bits_per_char == 4:
return _encode_int16(code)
if bits_per_char == 2:
return _encode_int4(code)
raise ValueError('`bits_per_char` must be in {6, 4, 2}') | [
"def",
"encode_int",
"(",
"code",
",",
"bits_per_char",
"=",
"6",
")",
":",
"if",
"code",
"<",
"0",
":",
"raise",
"ValueError",
"(",
"'Only positive ints are allowed!'",
")",
"if",
"bits_per_char",
"==",
"6",
":",
"return",
"_encode_int64",
"(",
"code",
")",
"if",
"bits_per_char",
"==",
"4",
":",
"return",
"_encode_int16",
"(",
"code",
")",
"if",
"bits_per_char",
"==",
"2",
":",
"return",
"_encode_int4",
"(",
"code",
")",
"raise",
"ValueError",
"(",
"'`bits_per_char` must be in {6, 4, 2}'",
")"
] | Encode int into a string preserving order
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
code: int Positive integer.
bits_per_char: int The number of bits per coding character.
Returns:
str: the encoded integer | [
"Encode",
"int",
"into",
"a",
"string",
"preserving",
"order"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_int2str.py#L27-L49 |
tammoippen/geohash-hilbert | geohash_hilbert/_int2str.py | decode_int | def decode_int(tag, bits_per_char=6):
"""Decode string into int assuming encoding with `encode_int()`
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
tag: str Encoded integer.
bits_per_char: int The number of bits per coding character.
Returns:
int: the decoded string
"""
if bits_per_char == 6:
return _decode_int64(tag)
if bits_per_char == 4:
return _decode_int16(tag)
if bits_per_char == 2:
return _decode_int4(tag)
raise ValueError('`bits_per_char` must be in {6, 4, 2}') | python | def decode_int(tag, bits_per_char=6):
"""Decode string into int assuming encoding with `encode_int()`
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
tag: str Encoded integer.
bits_per_char: int The number of bits per coding character.
Returns:
int: the decoded string
"""
if bits_per_char == 6:
return _decode_int64(tag)
if bits_per_char == 4:
return _decode_int16(tag)
if bits_per_char == 2:
return _decode_int4(tag)
raise ValueError('`bits_per_char` must be in {6, 4, 2}') | [
"def",
"decode_int",
"(",
"tag",
",",
"bits_per_char",
"=",
"6",
")",
":",
"if",
"bits_per_char",
"==",
"6",
":",
"return",
"_decode_int64",
"(",
"tag",
")",
"if",
"bits_per_char",
"==",
"4",
":",
"return",
"_decode_int16",
"(",
"tag",
")",
"if",
"bits_per_char",
"==",
"2",
":",
"return",
"_decode_int4",
"(",
"tag",
")",
"raise",
"ValueError",
"(",
"'`bits_per_char` must be in {6, 4, 2}'",
")"
] | Decode string into int assuming encoding with `encode_int()`
It is using 2, 4 or 6 bits per coding character (default 6).
Parameters:
tag: str Encoded integer.
bits_per_char: int The number of bits per coding character.
Returns:
int: the decoded string | [
"Decode",
"string",
"into",
"int",
"assuming",
"encoding",
"with",
"encode_int",
"()"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_int2str.py#L52-L71 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | encode | def encode(lng, lat, precision=10, bits_per_char=6):
"""Encode a lng/lat position as a geohash using a hilbert curve
This function encodes a lng/lat coordinate to a geohash of length `precision`
on a corresponding a hilbert curve. Each character encodes `bits_per_char` bits
per character (allowed are 2, 4 and 6 bits [default 6]). Hence, the geohash encodes
the lng/lat coordinate using `precision` * `bits_per_char` bits. The number of
bits devided by 2 give the level of the used hilbert curve, e.g. precision=10, bits_per_char=6
(default values) use 60 bit and a level 30 hilbert curve to map the globe.
Parameters:
lng: float Longitude; between -180.0 and 180.0; WGS 84
lat: float Latitude; between -90.0 and 90.0; WGS 84
precision: int The number of characters in a geohash
bits_per_char: int The number of bits per coding character
Returns:
str: geohash for lng/lat of length `precision`
"""
assert _LNG_INTERVAL[0] <= lng <= _LNG_INTERVAL[1]
assert _LAT_INTERVAL[0] <= lat <= _LAT_INTERVAL[1]
assert precision > 0
assert bits_per_char in (2, 4, 6)
bits = precision * bits_per_char
level = bits >> 1
dim = 1 << level
x, y = _coord2int(lng, lat, dim)
if CYTHON_AVAILABLE and bits <= MAX_BITS:
code = xy2hash_cython(x, y, dim)
else:
code = _xy2hash(x, y, dim)
return encode_int(code, bits_per_char).rjust(precision, '0') | python | def encode(lng, lat, precision=10, bits_per_char=6):
"""Encode a lng/lat position as a geohash using a hilbert curve
This function encodes a lng/lat coordinate to a geohash of length `precision`
on a corresponding a hilbert curve. Each character encodes `bits_per_char` bits
per character (allowed are 2, 4 and 6 bits [default 6]). Hence, the geohash encodes
the lng/lat coordinate using `precision` * `bits_per_char` bits. The number of
bits devided by 2 give the level of the used hilbert curve, e.g. precision=10, bits_per_char=6
(default values) use 60 bit and a level 30 hilbert curve to map the globe.
Parameters:
lng: float Longitude; between -180.0 and 180.0; WGS 84
lat: float Latitude; between -90.0 and 90.0; WGS 84
precision: int The number of characters in a geohash
bits_per_char: int The number of bits per coding character
Returns:
str: geohash for lng/lat of length `precision`
"""
assert _LNG_INTERVAL[0] <= lng <= _LNG_INTERVAL[1]
assert _LAT_INTERVAL[0] <= lat <= _LAT_INTERVAL[1]
assert precision > 0
assert bits_per_char in (2, 4, 6)
bits = precision * bits_per_char
level = bits >> 1
dim = 1 << level
x, y = _coord2int(lng, lat, dim)
if CYTHON_AVAILABLE and bits <= MAX_BITS:
code = xy2hash_cython(x, y, dim)
else:
code = _xy2hash(x, y, dim)
return encode_int(code, bits_per_char).rjust(precision, '0') | [
"def",
"encode",
"(",
"lng",
",",
"lat",
",",
"precision",
"=",
"10",
",",
"bits_per_char",
"=",
"6",
")",
":",
"assert",
"_LNG_INTERVAL",
"[",
"0",
"]",
"<=",
"lng",
"<=",
"_LNG_INTERVAL",
"[",
"1",
"]",
"assert",
"_LAT_INTERVAL",
"[",
"0",
"]",
"<=",
"lat",
"<=",
"_LAT_INTERVAL",
"[",
"1",
"]",
"assert",
"precision",
">",
"0",
"assert",
"bits_per_char",
"in",
"(",
"2",
",",
"4",
",",
"6",
")",
"bits",
"=",
"precision",
"*",
"bits_per_char",
"level",
"=",
"bits",
">>",
"1",
"dim",
"=",
"1",
"<<",
"level",
"x",
",",
"y",
"=",
"_coord2int",
"(",
"lng",
",",
"lat",
",",
"dim",
")",
"if",
"CYTHON_AVAILABLE",
"and",
"bits",
"<=",
"MAX_BITS",
":",
"code",
"=",
"xy2hash_cython",
"(",
"x",
",",
"y",
",",
"dim",
")",
"else",
":",
"code",
"=",
"_xy2hash",
"(",
"x",
",",
"y",
",",
"dim",
")",
"return",
"encode_int",
"(",
"code",
",",
"bits_per_char",
")",
".",
"rjust",
"(",
"precision",
",",
"'0'",
")"
] | Encode a lng/lat position as a geohash using a hilbert curve
This function encodes a lng/lat coordinate to a geohash of length `precision`
on a corresponding a hilbert curve. Each character encodes `bits_per_char` bits
per character (allowed are 2, 4 and 6 bits [default 6]). Hence, the geohash encodes
the lng/lat coordinate using `precision` * `bits_per_char` bits. The number of
bits devided by 2 give the level of the used hilbert curve, e.g. precision=10, bits_per_char=6
(default values) use 60 bit and a level 30 hilbert curve to map the globe.
Parameters:
lng: float Longitude; between -180.0 and 180.0; WGS 84
lat: float Latitude; between -90.0 and 90.0; WGS 84
precision: int The number of characters in a geohash
bits_per_char: int The number of bits per coding character
Returns:
str: geohash for lng/lat of length `precision` | [
"Encode",
"a",
"lng",
"/",
"lat",
"position",
"as",
"a",
"geohash",
"using",
"a",
"hilbert",
"curve"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L41-L76 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | decode | def decode(code, bits_per_char=6):
"""Decode a geohash on a hilbert curve as a lng/lat position
Decodes the geohash `code` as a lng/lat position. It assumes, that
the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float]: (lng, lat) coordinate for the geohash.
"""
assert bits_per_char in (2, 4, 6)
if len(code) == 0:
return 0., 0.
lng, lat, _lng_err, _lat_err = decode_exactly(code, bits_per_char)
return lng, lat | python | def decode(code, bits_per_char=6):
"""Decode a geohash on a hilbert curve as a lng/lat position
Decodes the geohash `code` as a lng/lat position. It assumes, that
the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float]: (lng, lat) coordinate for the geohash.
"""
assert bits_per_char in (2, 4, 6)
if len(code) == 0:
return 0., 0.
lng, lat, _lng_err, _lat_err = decode_exactly(code, bits_per_char)
return lng, lat | [
"def",
"decode",
"(",
"code",
",",
"bits_per_char",
"=",
"6",
")",
":",
"assert",
"bits_per_char",
"in",
"(",
"2",
",",
"4",
",",
"6",
")",
"if",
"len",
"(",
"code",
")",
"==",
"0",
":",
"return",
"0.",
",",
"0.",
"lng",
",",
"lat",
",",
"_lng_err",
",",
"_lat_err",
"=",
"decode_exactly",
"(",
"code",
",",
"bits_per_char",
")",
"return",
"lng",
",",
"lat"
] | Decode a geohash on a hilbert curve as a lng/lat position
Decodes the geohash `code` as a lng/lat position. It assumes, that
the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float]: (lng, lat) coordinate for the geohash. | [
"Decode",
"a",
"geohash",
"on",
"a",
"hilbert",
"curve",
"as",
"a",
"lng",
"/",
"lat",
"position"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L79-L100 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | decode_exactly | def decode_exactly(code, bits_per_char=6):
"""Decode a geohash on a hilbert curve as a lng/lat position with error-margins
Decodes the geohash `code` as a lng/lat position with error-margins. It assumes,
that the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float, float, float]: (lng, lat, lng-error, lat-error) coordinate for the geohash.
"""
assert bits_per_char in (2, 4, 6)
if len(code) == 0:
return 0., 0., _LNG_INTERVAL[1], _LAT_INTERVAL[1]
bits = len(code) * bits_per_char
level = bits >> 1
dim = 1 << level
code_int = decode_int(code, bits_per_char)
if CYTHON_AVAILABLE and bits <= MAX_BITS:
x, y = hash2xy_cython(code_int, dim)
else:
x, y = _hash2xy(code_int, dim)
lng, lat = _int2coord(x, y, dim)
lng_err, lat_err = _lvl_error(level) # level of hilbert curve is bits / 2
return lng + lng_err, lat + lat_err, lng_err, lat_err | python | def decode_exactly(code, bits_per_char=6):
"""Decode a geohash on a hilbert curve as a lng/lat position with error-margins
Decodes the geohash `code` as a lng/lat position with error-margins. It assumes,
that the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float, float, float]: (lng, lat, lng-error, lat-error) coordinate for the geohash.
"""
assert bits_per_char in (2, 4, 6)
if len(code) == 0:
return 0., 0., _LNG_INTERVAL[1], _LAT_INTERVAL[1]
bits = len(code) * bits_per_char
level = bits >> 1
dim = 1 << level
code_int = decode_int(code, bits_per_char)
if CYTHON_AVAILABLE and bits <= MAX_BITS:
x, y = hash2xy_cython(code_int, dim)
else:
x, y = _hash2xy(code_int, dim)
lng, lat = _int2coord(x, y, dim)
lng_err, lat_err = _lvl_error(level) # level of hilbert curve is bits / 2
return lng + lng_err, lat + lat_err, lng_err, lat_err | [
"def",
"decode_exactly",
"(",
"code",
",",
"bits_per_char",
"=",
"6",
")",
":",
"assert",
"bits_per_char",
"in",
"(",
"2",
",",
"4",
",",
"6",
")",
"if",
"len",
"(",
"code",
")",
"==",
"0",
":",
"return",
"0.",
",",
"0.",
",",
"_LNG_INTERVAL",
"[",
"1",
"]",
",",
"_LAT_INTERVAL",
"[",
"1",
"]",
"bits",
"=",
"len",
"(",
"code",
")",
"*",
"bits_per_char",
"level",
"=",
"bits",
">>",
"1",
"dim",
"=",
"1",
"<<",
"level",
"code_int",
"=",
"decode_int",
"(",
"code",
",",
"bits_per_char",
")",
"if",
"CYTHON_AVAILABLE",
"and",
"bits",
"<=",
"MAX_BITS",
":",
"x",
",",
"y",
"=",
"hash2xy_cython",
"(",
"code_int",
",",
"dim",
")",
"else",
":",
"x",
",",
"y",
"=",
"_hash2xy",
"(",
"code_int",
",",
"dim",
")",
"lng",
",",
"lat",
"=",
"_int2coord",
"(",
"x",
",",
"y",
",",
"dim",
")",
"lng_err",
",",
"lat_err",
"=",
"_lvl_error",
"(",
"level",
")",
"# level of hilbert curve is bits / 2",
"return",
"lng",
"+",
"lng_err",
",",
"lat",
"+",
"lat_err",
",",
"lng_err",
",",
"lat_err"
] | Decode a geohash on a hilbert curve as a lng/lat position with error-margins
Decodes the geohash `code` as a lng/lat position with error-margins. It assumes,
that the length of `code` corresponds to the precision! And that each character
in `code` encodes `bits_per_char` bits. Do not mix geohashes with different
`bits_per_char`!
Parameters:
code: str The geohash to decode.
bits_per_char: int The number of bits per coding character
Returns:
Tuple[float, float, float, float]: (lng, lat, lng-error, lat-error) coordinate for the geohash. | [
"Decode",
"a",
"geohash",
"on",
"a",
"hilbert",
"curve",
"as",
"a",
"lng",
"/",
"lat",
"position",
"with",
"error",
"-",
"margins"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L103-L136 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | _coord2int | def _coord2int(lng, lat, dim):
"""Convert lon, lat values into a dim x dim-grid coordinate system.
Parameters:
lng: float Longitude value of coordinate (-180.0, 180.0); corresponds to X axis
lat: float Latitude value of coordinate (-90.0, 90.0); corresponds to Y axis
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]:
Lower left corner of corresponding dim x dim-grid box
x x value of point [0, dim); corresponds to longitude
y y value of point [0, dim); corresponds to latitude
"""
assert dim >= 1
lat_y = (lat + _LAT_INTERVAL[1]) / 180.0 * dim # [0 ... dim)
lng_x = (lng + _LNG_INTERVAL[1]) / 360.0 * dim # [0 ... dim)
return min(dim - 1, int(floor(lng_x))), min(dim - 1, int(floor(lat_y))) | python | def _coord2int(lng, lat, dim):
"""Convert lon, lat values into a dim x dim-grid coordinate system.
Parameters:
lng: float Longitude value of coordinate (-180.0, 180.0); corresponds to X axis
lat: float Latitude value of coordinate (-90.0, 90.0); corresponds to Y axis
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]:
Lower left corner of corresponding dim x dim-grid box
x x value of point [0, dim); corresponds to longitude
y y value of point [0, dim); corresponds to latitude
"""
assert dim >= 1
lat_y = (lat + _LAT_INTERVAL[1]) / 180.0 * dim # [0 ... dim)
lng_x = (lng + _LNG_INTERVAL[1]) / 360.0 * dim # [0 ... dim)
return min(dim - 1, int(floor(lng_x))), min(dim - 1, int(floor(lat_y))) | [
"def",
"_coord2int",
"(",
"lng",
",",
"lat",
",",
"dim",
")",
":",
"assert",
"dim",
">=",
"1",
"lat_y",
"=",
"(",
"lat",
"+",
"_LAT_INTERVAL",
"[",
"1",
"]",
")",
"/",
"180.0",
"*",
"dim",
"# [0 ... dim)",
"lng_x",
"=",
"(",
"lng",
"+",
"_LNG_INTERVAL",
"[",
"1",
"]",
")",
"/",
"360.0",
"*",
"dim",
"# [0 ... dim)",
"return",
"min",
"(",
"dim",
"-",
"1",
",",
"int",
"(",
"floor",
"(",
"lng_x",
")",
")",
")",
",",
"min",
"(",
"dim",
"-",
"1",
",",
"int",
"(",
"floor",
"(",
"lat_y",
")",
")",
")"
] | Convert lon, lat values into a dim x dim-grid coordinate system.
Parameters:
lng: float Longitude value of coordinate (-180.0, 180.0); corresponds to X axis
lat: float Latitude value of coordinate (-90.0, 90.0); corresponds to Y axis
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]:
Lower left corner of corresponding dim x dim-grid box
x x value of point [0, dim); corresponds to longitude
y y value of point [0, dim); corresponds to latitude | [
"Convert",
"lon",
"lat",
"values",
"into",
"a",
"dim",
"x",
"dim",
"-",
"grid",
"coordinate",
"system",
"."
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L157-L177 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | _int2coord | def _int2coord(x, y, dim):
"""Convert x, y values in dim x dim-grid coordinate system into lng, lat values.
Parameters:
x: int x value of point [0, dim); corresponds to longitude
y: int y value of point [0, dim); corresponds to latitude
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[float, float]: (lng, lat)
lng longitude value of coordinate [-180.0, 180.0]; corresponds to X axis
lat latitude value of coordinate [-90.0, 90.0]; corresponds to Y axis
"""
assert dim >= 1
assert x < dim
assert y < dim
lng = x / dim * 360 - 180
lat = y / dim * 180 - 90
return lng, lat | python | def _int2coord(x, y, dim):
"""Convert x, y values in dim x dim-grid coordinate system into lng, lat values.
Parameters:
x: int x value of point [0, dim); corresponds to longitude
y: int y value of point [0, dim); corresponds to latitude
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[float, float]: (lng, lat)
lng longitude value of coordinate [-180.0, 180.0]; corresponds to X axis
lat latitude value of coordinate [-90.0, 90.0]; corresponds to Y axis
"""
assert dim >= 1
assert x < dim
assert y < dim
lng = x / dim * 360 - 180
lat = y / dim * 180 - 90
return lng, lat | [
"def",
"_int2coord",
"(",
"x",
",",
"y",
",",
"dim",
")",
":",
"assert",
"dim",
">=",
"1",
"assert",
"x",
"<",
"dim",
"assert",
"y",
"<",
"dim",
"lng",
"=",
"x",
"/",
"dim",
"*",
"360",
"-",
"180",
"lat",
"=",
"y",
"/",
"dim",
"*",
"180",
"-",
"90",
"return",
"lng",
",",
"lat"
] | Convert x, y values in dim x dim-grid coordinate system into lng, lat values.
Parameters:
x: int x value of point [0, dim); corresponds to longitude
y: int y value of point [0, dim); corresponds to latitude
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[float, float]: (lng, lat)
lng longitude value of coordinate [-180.0, 180.0]; corresponds to X axis
lat latitude value of coordinate [-90.0, 90.0]; corresponds to Y axis | [
"Convert",
"x",
"y",
"values",
"in",
"dim",
"x",
"dim",
"-",
"grid",
"coordinate",
"system",
"into",
"lng",
"lat",
"values",
"."
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L180-L201 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | _xy2hash | def _xy2hash(x, y, dim):
"""Convert (x, y) to hashcode.
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
x: int x value of point [0, dim) in dim x dim coord system
y: int y value of point [0, dim) in dim x dim coord system
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
int: hashcode ∈ [0, dim**2)
"""
d = 0
lvl = dim >> 1
while (lvl > 0):
rx = int((x & lvl) > 0)
ry = int((y & lvl) > 0)
d += lvl * lvl * ((3 * rx) ^ ry)
x, y = _rotate(lvl, x, y, rx, ry)
lvl >>= 1
return d | python | def _xy2hash(x, y, dim):
"""Convert (x, y) to hashcode.
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
x: int x value of point [0, dim) in dim x dim coord system
y: int y value of point [0, dim) in dim x dim coord system
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
int: hashcode ∈ [0, dim**2)
"""
d = 0
lvl = dim >> 1
while (lvl > 0):
rx = int((x & lvl) > 0)
ry = int((y & lvl) > 0)
d += lvl * lvl * ((3 * rx) ^ ry)
x, y = _rotate(lvl, x, y, rx, ry)
lvl >>= 1
return d | [
"def",
"_xy2hash",
"(",
"x",
",",
"y",
",",
"dim",
")",
":",
"d",
"=",
"0",
"lvl",
"=",
"dim",
">>",
"1",
"while",
"(",
"lvl",
">",
"0",
")",
":",
"rx",
"=",
"int",
"(",
"(",
"x",
"&",
"lvl",
")",
">",
"0",
")",
"ry",
"=",
"int",
"(",
"(",
"y",
"&",
"lvl",
")",
">",
"0",
")",
"d",
"+=",
"lvl",
"*",
"lvl",
"*",
"(",
"(",
"3",
"*",
"rx",
")",
"^",
"ry",
")",
"x",
",",
"y",
"=",
"_rotate",
"(",
"lvl",
",",
"x",
",",
"y",
",",
"rx",
",",
"ry",
")",
"lvl",
">>=",
"1",
"return",
"d"
] | Convert (x, y) to hashcode.
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
x: int x value of point [0, dim) in dim x dim coord system
y: int y value of point [0, dim) in dim x dim coord system
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
int: hashcode ∈ [0, dim**2) | [
"Convert",
"(",
"x",
"y",
")",
"to",
"hashcode",
"."
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L205-L230 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | _hash2xy | def _hash2xy(hashcode, dim):
"""Convert hashcode to (x, y).
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
hashcode: int Hashcode to decode [0, dim**2)
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]: (x, y) point in dim x dim-grid system
"""
assert(hashcode <= dim * dim - 1)
x = y = 0
lvl = 1
while (lvl < dim):
rx = 1 & (hashcode >> 1)
ry = 1 & (hashcode ^ rx)
x, y = _rotate(lvl, x, y, rx, ry)
x += lvl * rx
y += lvl * ry
hashcode >>= 2
lvl <<= 1
return x, y | python | def _hash2xy(hashcode, dim):
"""Convert hashcode to (x, y).
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
hashcode: int Hashcode to decode [0, dim**2)
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]: (x, y) point in dim x dim-grid system
"""
assert(hashcode <= dim * dim - 1)
x = y = 0
lvl = 1
while (lvl < dim):
rx = 1 & (hashcode >> 1)
ry = 1 & (hashcode ^ rx)
x, y = _rotate(lvl, x, y, rx, ry)
x += lvl * rx
y += lvl * ry
hashcode >>= 2
lvl <<= 1
return x, y | [
"def",
"_hash2xy",
"(",
"hashcode",
",",
"dim",
")",
":",
"assert",
"(",
"hashcode",
"<=",
"dim",
"*",
"dim",
"-",
"1",
")",
"x",
"=",
"y",
"=",
"0",
"lvl",
"=",
"1",
"while",
"(",
"lvl",
"<",
"dim",
")",
":",
"rx",
"=",
"1",
"&",
"(",
"hashcode",
">>",
"1",
")",
"ry",
"=",
"1",
"&",
"(",
"hashcode",
"^",
"rx",
")",
"x",
",",
"y",
"=",
"_rotate",
"(",
"lvl",
",",
"x",
",",
"y",
",",
"rx",
",",
"ry",
")",
"x",
"+=",
"lvl",
"*",
"rx",
"y",
"+=",
"lvl",
"*",
"ry",
"hashcode",
">>=",
"2",
"lvl",
"<<=",
"1",
"return",
"x",
",",
"y"
] | Convert hashcode to (x, y).
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
Pure python implementation.
Parameters:
hashcode: int Hashcode to decode [0, dim**2)
dim: int Number of coding points each x, y value can take.
Corresponds to 2^level of the hilbert curve.
Returns:
Tuple[int, int]: (x, y) point in dim x dim-grid system | [
"Convert",
"hashcode",
"to",
"(",
"x",
"y",
")",
"."
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L233-L260 |
tammoippen/geohash-hilbert | geohash_hilbert/_hilbert.py | _rotate | def _rotate(n, x, y, rx, ry):
"""Rotate and flip a quadrant appropriately
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
"""
if ry == 0:
if rx == 1:
x = n - 1 - x
y = n - 1 - y
return y, x
return x, y | python | def _rotate(n, x, y, rx, ry):
"""Rotate and flip a quadrant appropriately
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503
"""
if ry == 0:
if rx == 1:
x = n - 1 - x
y = n - 1 - y
return y, x
return x, y | [
"def",
"_rotate",
"(",
"n",
",",
"x",
",",
"y",
",",
"rx",
",",
"ry",
")",
":",
"if",
"ry",
"==",
"0",
":",
"if",
"rx",
"==",
"1",
":",
"x",
"=",
"n",
"-",
"1",
"-",
"x",
"y",
"=",
"n",
"-",
"1",
"-",
"y",
"return",
"y",
",",
"x",
"return",
"x",
",",
"y"
] | Rotate and flip a quadrant appropriately
Based on the implementation here:
https://en.wikipedia.org/w/index.php?title=Hilbert_curve&oldid=797332503 | [
"Rotate",
"and",
"flip",
"a",
"quadrant",
"appropriately"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_hilbert.py#L263-L275 |
tammoippen/geohash-hilbert | geohash_hilbert/_utils.py | neighbours | def neighbours(code, bits_per_char=6):
"""Get the neighbouring geohashes for `code`.
Look for the north, north-east, east, south-east, south, south-west, west,
north-west neighbours. If you are at the east/west edge of the grid
(lng ∈ (-180, 180)), then it wraps around the globe and gets the corresponding
neighbor.
Parameters:
code: str The geohash at the center.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geohashes in the neighborhood of `code`. Possible keys are 'north',
'north-east', 'east', 'south-east', 'south', 'south-west',
'west', 'north-west'. If the input code covers the north pole, then
keys 'north', 'north-east', and 'north-west' are not present, and if
the input code covers the south pole then keys 'south', 'south-west',
and 'south-east' are not present.
"""
lng, lat, lng_err, lat_err = decode_exactly(code, bits_per_char)
precision = len(code)
north = lat + 2 * lat_err
south = lat - 2 * lat_err
east = lng + 2 * lng_err
if east > 180:
east -= 360
west = lng - 2 * lng_err
if west < -180:
west += 360
neighbours_dict = {
'east': encode(east, lat, precision, bits_per_char), # noqa: E241
'west': encode(west, lat, precision, bits_per_char), # noqa: E241
}
if north <= 90: # input cell not already at the north pole
neighbours_dict.update({
'north': encode(lng, north, precision, bits_per_char), # noqa: E241
'north-east': encode(east, north, precision, bits_per_char), # noqa: E241
'north-west': encode(west, north, precision, bits_per_char), # noqa: E241
})
if south >= -90: # input cell not already at the south pole
neighbours_dict.update({
'south': encode(lng, south, precision, bits_per_char), # noqa: E241
'south-east': encode(east, south, precision, bits_per_char), # noqa: E241
'south-west': encode(west, south, precision, bits_per_char), # noqa: E241
})
return neighbours_dict | python | def neighbours(code, bits_per_char=6):
"""Get the neighbouring geohashes for `code`.
Look for the north, north-east, east, south-east, south, south-west, west,
north-west neighbours. If you are at the east/west edge of the grid
(lng ∈ (-180, 180)), then it wraps around the globe and gets the corresponding
neighbor.
Parameters:
code: str The geohash at the center.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geohashes in the neighborhood of `code`. Possible keys are 'north',
'north-east', 'east', 'south-east', 'south', 'south-west',
'west', 'north-west'. If the input code covers the north pole, then
keys 'north', 'north-east', and 'north-west' are not present, and if
the input code covers the south pole then keys 'south', 'south-west',
and 'south-east' are not present.
"""
lng, lat, lng_err, lat_err = decode_exactly(code, bits_per_char)
precision = len(code)
north = lat + 2 * lat_err
south = lat - 2 * lat_err
east = lng + 2 * lng_err
if east > 180:
east -= 360
west = lng - 2 * lng_err
if west < -180:
west += 360
neighbours_dict = {
'east': encode(east, lat, precision, bits_per_char), # noqa: E241
'west': encode(west, lat, precision, bits_per_char), # noqa: E241
}
if north <= 90: # input cell not already at the north pole
neighbours_dict.update({
'north': encode(lng, north, precision, bits_per_char), # noqa: E241
'north-east': encode(east, north, precision, bits_per_char), # noqa: E241
'north-west': encode(west, north, precision, bits_per_char), # noqa: E241
})
if south >= -90: # input cell not already at the south pole
neighbours_dict.update({
'south': encode(lng, south, precision, bits_per_char), # noqa: E241
'south-east': encode(east, south, precision, bits_per_char), # noqa: E241
'south-west': encode(west, south, precision, bits_per_char), # noqa: E241
})
return neighbours_dict | [
"def",
"neighbours",
"(",
"code",
",",
"bits_per_char",
"=",
"6",
")",
":",
"lng",
",",
"lat",
",",
"lng_err",
",",
"lat_err",
"=",
"decode_exactly",
"(",
"code",
",",
"bits_per_char",
")",
"precision",
"=",
"len",
"(",
"code",
")",
"north",
"=",
"lat",
"+",
"2",
"*",
"lat_err",
"south",
"=",
"lat",
"-",
"2",
"*",
"lat_err",
"east",
"=",
"lng",
"+",
"2",
"*",
"lng_err",
"if",
"east",
">",
"180",
":",
"east",
"-=",
"360",
"west",
"=",
"lng",
"-",
"2",
"*",
"lng_err",
"if",
"west",
"<",
"-",
"180",
":",
"west",
"+=",
"360",
"neighbours_dict",
"=",
"{",
"'east'",
":",
"encode",
"(",
"east",
",",
"lat",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"'west'",
":",
"encode",
"(",
"west",
",",
"lat",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"}",
"if",
"north",
"<=",
"90",
":",
"# input cell not already at the north pole",
"neighbours_dict",
".",
"update",
"(",
"{",
"'north'",
":",
"encode",
"(",
"lng",
",",
"north",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"'north-east'",
":",
"encode",
"(",
"east",
",",
"north",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"'north-west'",
":",
"encode",
"(",
"west",
",",
"north",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"}",
")",
"if",
"south",
">=",
"-",
"90",
":",
"# input cell not already at the south pole",
"neighbours_dict",
".",
"update",
"(",
"{",
"'south'",
":",
"encode",
"(",
"lng",
",",
"south",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"'south-east'",
":",
"encode",
"(",
"east",
",",
"south",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"'south-west'",
":",
"encode",
"(",
"west",
",",
"south",
",",
"precision",
",",
"bits_per_char",
")",
",",
"# noqa: E241",
"}",
")",
"return",
"neighbours_dict"
] | Get the neighbouring geohashes for `code`.
Look for the north, north-east, east, south-east, south, south-west, west,
north-west neighbours. If you are at the east/west edge of the grid
(lng ∈ (-180, 180)), then it wraps around the globe and gets the corresponding
neighbor.
Parameters:
code: str The geohash at the center.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geohashes in the neighborhood of `code`. Possible keys are 'north',
'north-east', 'east', 'south-east', 'south', 'south-west',
'west', 'north-west'. If the input code covers the north pole, then
keys 'north', 'north-east', and 'north-west' are not present, and if
the input code covers the south pole then keys 'south', 'south-west',
and 'south-east' are not present. | [
"Get",
"the",
"neighbouring",
"geohashes",
"for",
"code",
"."
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_utils.py#L30-L84 |
tammoippen/geohash-hilbert | geohash_hilbert/_utils.py | rectangle | def rectangle(code, bits_per_char=6):
"""Builds a (geojson) rectangle from `code`
The center of the rectangle decodes as the lng/lat for code and
the rectangle corresponds to the error-margin, i.e. every lng/lat
point within this rectangle will be encoded as `code`, given `precision == len(code)`.
Parameters:
code: str The geohash for which the rectangle should be build.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the rectangle as a `Polygon`.
"""
lng, lat, lng_err, lat_err = decode_exactly(code, bits_per_char)
return {
'type': 'Feature',
'properties': {
'code': code,
'lng': lng,
'lat': lat,
'lng_err': lng_err,
'lat_err': lat_err,
'bits_per_char': bits_per_char,
},
'bbox': (
lng - lng_err, # bottom left
lat - lat_err,
lng + lng_err, # top right
lat + lat_err,
),
'geometry': {
'type': 'Polygon',
'coordinates': [[
(lng - lng_err, lat - lat_err),
(lng + lng_err, lat - lat_err),
(lng + lng_err, lat + lat_err),
(lng - lng_err, lat + lat_err),
(lng - lng_err, lat - lat_err),
]],
},
} | python | def rectangle(code, bits_per_char=6):
"""Builds a (geojson) rectangle from `code`
The center of the rectangle decodes as the lng/lat for code and
the rectangle corresponds to the error-margin, i.e. every lng/lat
point within this rectangle will be encoded as `code`, given `precision == len(code)`.
Parameters:
code: str The geohash for which the rectangle should be build.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the rectangle as a `Polygon`.
"""
lng, lat, lng_err, lat_err = decode_exactly(code, bits_per_char)
return {
'type': 'Feature',
'properties': {
'code': code,
'lng': lng,
'lat': lat,
'lng_err': lng_err,
'lat_err': lat_err,
'bits_per_char': bits_per_char,
},
'bbox': (
lng - lng_err, # bottom left
lat - lat_err,
lng + lng_err, # top right
lat + lat_err,
),
'geometry': {
'type': 'Polygon',
'coordinates': [[
(lng - lng_err, lat - lat_err),
(lng + lng_err, lat - lat_err),
(lng + lng_err, lat + lat_err),
(lng - lng_err, lat + lat_err),
(lng - lng_err, lat - lat_err),
]],
},
} | [
"def",
"rectangle",
"(",
"code",
",",
"bits_per_char",
"=",
"6",
")",
":",
"lng",
",",
"lat",
",",
"lng_err",
",",
"lat_err",
"=",
"decode_exactly",
"(",
"code",
",",
"bits_per_char",
")",
"return",
"{",
"'type'",
":",
"'Feature'",
",",
"'properties'",
":",
"{",
"'code'",
":",
"code",
",",
"'lng'",
":",
"lng",
",",
"'lat'",
":",
"lat",
",",
"'lng_err'",
":",
"lng_err",
",",
"'lat_err'",
":",
"lat_err",
",",
"'bits_per_char'",
":",
"bits_per_char",
",",
"}",
",",
"'bbox'",
":",
"(",
"lng",
"-",
"lng_err",
",",
"# bottom left",
"lat",
"-",
"lat_err",
",",
"lng",
"+",
"lng_err",
",",
"# top right",
"lat",
"+",
"lat_err",
",",
")",
",",
"'geometry'",
":",
"{",
"'type'",
":",
"'Polygon'",
",",
"'coordinates'",
":",
"[",
"[",
"(",
"lng",
"-",
"lng_err",
",",
"lat",
"-",
"lat_err",
")",
",",
"(",
"lng",
"+",
"lng_err",
",",
"lat",
"-",
"lat_err",
")",
",",
"(",
"lng",
"+",
"lng_err",
",",
"lat",
"+",
"lat_err",
")",
",",
"(",
"lng",
"-",
"lng_err",
",",
"lat",
"+",
"lat_err",
")",
",",
"(",
"lng",
"-",
"lng_err",
",",
"lat",
"-",
"lat_err",
")",
",",
"]",
"]",
",",
"}",
",",
"}"
] | Builds a (geojson) rectangle from `code`
The center of the rectangle decodes as the lng/lat for code and
the rectangle corresponds to the error-margin, i.e. every lng/lat
point within this rectangle will be encoded as `code`, given `precision == len(code)`.
Parameters:
code: str The geohash for which the rectangle should be build.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the rectangle as a `Polygon`. | [
"Builds",
"a",
"(",
"geojson",
")",
"rectangle",
"from",
"code"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_utils.py#L87-L129 |
tammoippen/geohash-hilbert | geohash_hilbert/_utils.py | hilbert_curve | def hilbert_curve(precision, bits_per_char=6):
"""Build the (geojson) `LineString` of the used hilbert-curve
Builds the `LineString` of the used hilbert-curve given the `precision` and
the `bits_per_char`. The number of bits to encode the geohash is equal to
`precision * bits_per_char`, and for each level, you need 2 bits, hence
the number of bits has to be even. The more bits are used, the more precise
(and long) will the hilbert curve be, e.g. for geohashes of length 3 (precision)
and 6 bits per character, there will be 18 bits used and the curve will
consist of 2^18 = 262144 points.
Parameters:
precision: int The number of characters in a geohash.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the hilbert curve as a `LineString`.
"""
bits = precision * bits_per_char
coords = []
for i in range(1 << bits):
code = encode_int(i, bits_per_char).rjust(precision, '0')
coords += [decode(code, bits_per_char)]
return {
'type': 'Feature',
'properties': {},
'geometry': {
'type': 'LineString',
'coordinates': coords,
},
} | python | def hilbert_curve(precision, bits_per_char=6):
"""Build the (geojson) `LineString` of the used hilbert-curve
Builds the `LineString` of the used hilbert-curve given the `precision` and
the `bits_per_char`. The number of bits to encode the geohash is equal to
`precision * bits_per_char`, and for each level, you need 2 bits, hence
the number of bits has to be even. The more bits are used, the more precise
(and long) will the hilbert curve be, e.g. for geohashes of length 3 (precision)
and 6 bits per character, there will be 18 bits used and the curve will
consist of 2^18 = 262144 points.
Parameters:
precision: int The number of characters in a geohash.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the hilbert curve as a `LineString`.
"""
bits = precision * bits_per_char
coords = []
for i in range(1 << bits):
code = encode_int(i, bits_per_char).rjust(precision, '0')
coords += [decode(code, bits_per_char)]
return {
'type': 'Feature',
'properties': {},
'geometry': {
'type': 'LineString',
'coordinates': coords,
},
} | [
"def",
"hilbert_curve",
"(",
"precision",
",",
"bits_per_char",
"=",
"6",
")",
":",
"bits",
"=",
"precision",
"*",
"bits_per_char",
"coords",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"1",
"<<",
"bits",
")",
":",
"code",
"=",
"encode_int",
"(",
"i",
",",
"bits_per_char",
")",
".",
"rjust",
"(",
"precision",
",",
"'0'",
")",
"coords",
"+=",
"[",
"decode",
"(",
"code",
",",
"bits_per_char",
")",
"]",
"return",
"{",
"'type'",
":",
"'Feature'",
",",
"'properties'",
":",
"{",
"}",
",",
"'geometry'",
":",
"{",
"'type'",
":",
"'LineString'",
",",
"'coordinates'",
":",
"coords",
",",
"}",
",",
"}"
] | Build the (geojson) `LineString` of the used hilbert-curve
Builds the `LineString` of the used hilbert-curve given the `precision` and
the `bits_per_char`. The number of bits to encode the geohash is equal to
`precision * bits_per_char`, and for each level, you need 2 bits, hence
the number of bits has to be even. The more bits are used, the more precise
(and long) will the hilbert curve be, e.g. for geohashes of length 3 (precision)
and 6 bits per character, there will be 18 bits used and the curve will
consist of 2^18 = 262144 points.
Parameters:
precision: int The number of characters in a geohash.
bits_per_char: int The number of bits per coding character.
Returns:
dict: geojson `Feature` containing the hilbert curve as a `LineString`. | [
"Build",
"the",
"(",
"geojson",
")",
"LineString",
"of",
"the",
"used",
"hilbert",
"-",
"curve"
] | train | https://github.com/tammoippen/geohash-hilbert/blob/b74f0fc1bff0234d8ff367e4129c3324676b0b36/geohash_hilbert/_utils.py#L132-L164 |
cocagne/txdbus | txdbus/objects.py | isSignatureValid | def isSignatureValid(expected, received):
"""
Verifies that the received signature matches the expected value
"""
if expected:
if not received or expected != received:
return False
else:
if received:
return False
return True | python | def isSignatureValid(expected, received):
"""
Verifies that the received signature matches the expected value
"""
if expected:
if not received or expected != received:
return False
else:
if received:
return False
return True | [
"def",
"isSignatureValid",
"(",
"expected",
",",
"received",
")",
":",
"if",
"expected",
":",
"if",
"not",
"received",
"or",
"expected",
"!=",
"received",
":",
"return",
"False",
"else",
":",
"if",
"received",
":",
"return",
"False",
"return",
"True"
] | Verifies that the received signature matches the expected value | [
"Verifies",
"that",
"the",
"received",
"signature",
"matches",
"the",
"expected",
"value"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L17-L27 |
cocagne/txdbus | txdbus/objects.py | RemoteDBusObject.notifyOnDisconnect | def notifyOnDisconnect(self, callback):
"""
Registers a callback that will be called when the DBus connection
underlying the remote object is lost
@type callback: Callable object accepting a L{RemoteDBusObject} and
L{twisted.python.failure.Failure}
@param callback: Function that will be called when the connection to
the DBus session is lost. Arguments are the
L{RemoteDBusObject} instance and reason for the
disconnect (the same value passed to
L{twisted.internet.protocol.Protocol.connectionLost})
"""
if self._disconnectCBs is None:
self._disconnectCBs = []
self._disconnectCBs.append(callback) | python | def notifyOnDisconnect(self, callback):
"""
Registers a callback that will be called when the DBus connection
underlying the remote object is lost
@type callback: Callable object accepting a L{RemoteDBusObject} and
L{twisted.python.failure.Failure}
@param callback: Function that will be called when the connection to
the DBus session is lost. Arguments are the
L{RemoteDBusObject} instance and reason for the
disconnect (the same value passed to
L{twisted.internet.protocol.Protocol.connectionLost})
"""
if self._disconnectCBs is None:
self._disconnectCBs = []
self._disconnectCBs.append(callback) | [
"def",
"notifyOnDisconnect",
"(",
"self",
",",
"callback",
")",
":",
"if",
"self",
".",
"_disconnectCBs",
"is",
"None",
":",
"self",
".",
"_disconnectCBs",
"=",
"[",
"]",
"self",
".",
"_disconnectCBs",
".",
"append",
"(",
"callback",
")"
] | Registers a callback that will be called when the DBus connection
underlying the remote object is lost
@type callback: Callable object accepting a L{RemoteDBusObject} and
L{twisted.python.failure.Failure}
@param callback: Function that will be called when the connection to
the DBus session is lost. Arguments are the
L{RemoteDBusObject} instance and reason for the
disconnect (the same value passed to
L{twisted.internet.protocol.Protocol.connectionLost}) | [
"Registers",
"a",
"callback",
"that",
"will",
"be",
"called",
"when",
"the",
"DBus",
"connection",
"underlying",
"the",
"remote",
"object",
"is",
"lost"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L112-L127 |
cocagne/txdbus | txdbus/objects.py | RemoteDBusObject.connectionLost | def connectionLost(self, reason):
"""
Called by the L{DBusObjectHandler} when the connection is lost
"""
if self._disconnectCBs:
for cb in self._disconnectCBs:
cb(self, reason) | python | def connectionLost(self, reason):
"""
Called by the L{DBusObjectHandler} when the connection is lost
"""
if self._disconnectCBs:
for cb in self._disconnectCBs:
cb(self, reason) | [
"def",
"connectionLost",
"(",
"self",
",",
"reason",
")",
":",
"if",
"self",
".",
"_disconnectCBs",
":",
"for",
"cb",
"in",
"self",
".",
"_disconnectCBs",
":",
"cb",
"(",
"self",
",",
"reason",
")"
] | Called by the L{DBusObjectHandler} when the connection is lost | [
"Called",
"by",
"the",
"L",
"{",
"DBusObjectHandler",
"}",
"when",
"the",
"connection",
"is",
"lost"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L136-L142 |
cocagne/txdbus | txdbus/objects.py | RemoteDBusObject.notifyOnSignal | def notifyOnSignal(self, signalName, callback, interface=None):
"""
Informs the DBus daemon of the process's interest in the specified
signal and registers the callback function to be called when the
signal arrives. Multiple callbacks may be registered.
@type signalName: C{string}
@param signalName: Name of the signal to register the callback for
@type callback: Callable object
@param callback: Callback to be called on signal arrival. The callback
will be passed signals arguments as positional function arguments.
@type interface: C{string}
@param interface: Optional DBus interface emitting the signal. This is
only needed if more than one interface shares a signal with the
same name
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to an integer rule_id that may be passed to
cancelSignalNotification to prevent the delivery of future signals
to the callback
"""
iface = None
signal = None
for i in self.interfaces:
if interface and not i.name == interface:
continue
if signalName in i.signals:
signal = i.signals[signalName]
iface = i
break
def callback_caller(sig_msg):
if isSignatureValid(signal.sig, sig_msg.signature):
if sig_msg.body:
callback(*sig_msg.body)
else:
callback()
if iface is None:
raise AttributeError(
'Requested signal "%s" is not a member of any of the '
'supported interfaces' % (signalName,),
)
d = self.objHandler.conn.addMatch(
callback_caller,
mtype='signal',
path=self.objectPath,
member=signalName,
interface=iface.name,
)
def on_ok(rule_id):
if self._signalRules is None:
self._signalRules = set()
self._signalRules.add(rule_id)
return rule_id
d.addCallback(on_ok)
return d | python | def notifyOnSignal(self, signalName, callback, interface=None):
"""
Informs the DBus daemon of the process's interest in the specified
signal and registers the callback function to be called when the
signal arrives. Multiple callbacks may be registered.
@type signalName: C{string}
@param signalName: Name of the signal to register the callback for
@type callback: Callable object
@param callback: Callback to be called on signal arrival. The callback
will be passed signals arguments as positional function arguments.
@type interface: C{string}
@param interface: Optional DBus interface emitting the signal. This is
only needed if more than one interface shares a signal with the
same name
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to an integer rule_id that may be passed to
cancelSignalNotification to prevent the delivery of future signals
to the callback
"""
iface = None
signal = None
for i in self.interfaces:
if interface and not i.name == interface:
continue
if signalName in i.signals:
signal = i.signals[signalName]
iface = i
break
def callback_caller(sig_msg):
if isSignatureValid(signal.sig, sig_msg.signature):
if sig_msg.body:
callback(*sig_msg.body)
else:
callback()
if iface is None:
raise AttributeError(
'Requested signal "%s" is not a member of any of the '
'supported interfaces' % (signalName,),
)
d = self.objHandler.conn.addMatch(
callback_caller,
mtype='signal',
path=self.objectPath,
member=signalName,
interface=iface.name,
)
def on_ok(rule_id):
if self._signalRules is None:
self._signalRules = set()
self._signalRules.add(rule_id)
return rule_id
d.addCallback(on_ok)
return d | [
"def",
"notifyOnSignal",
"(",
"self",
",",
"signalName",
",",
"callback",
",",
"interface",
"=",
"None",
")",
":",
"iface",
"=",
"None",
"signal",
"=",
"None",
"for",
"i",
"in",
"self",
".",
"interfaces",
":",
"if",
"interface",
"and",
"not",
"i",
".",
"name",
"==",
"interface",
":",
"continue",
"if",
"signalName",
"in",
"i",
".",
"signals",
":",
"signal",
"=",
"i",
".",
"signals",
"[",
"signalName",
"]",
"iface",
"=",
"i",
"break",
"def",
"callback_caller",
"(",
"sig_msg",
")",
":",
"if",
"isSignatureValid",
"(",
"signal",
".",
"sig",
",",
"sig_msg",
".",
"signature",
")",
":",
"if",
"sig_msg",
".",
"body",
":",
"callback",
"(",
"*",
"sig_msg",
".",
"body",
")",
"else",
":",
"callback",
"(",
")",
"if",
"iface",
"is",
"None",
":",
"raise",
"AttributeError",
"(",
"'Requested signal \"%s\" is not a member of any of the '",
"'supported interfaces'",
"%",
"(",
"signalName",
",",
")",
",",
")",
"d",
"=",
"self",
".",
"objHandler",
".",
"conn",
".",
"addMatch",
"(",
"callback_caller",
",",
"mtype",
"=",
"'signal'",
",",
"path",
"=",
"self",
".",
"objectPath",
",",
"member",
"=",
"signalName",
",",
"interface",
"=",
"iface",
".",
"name",
",",
")",
"def",
"on_ok",
"(",
"rule_id",
")",
":",
"if",
"self",
".",
"_signalRules",
"is",
"None",
":",
"self",
".",
"_signalRules",
"=",
"set",
"(",
")",
"self",
".",
"_signalRules",
".",
"add",
"(",
"rule_id",
")",
"return",
"rule_id",
"d",
".",
"addCallback",
"(",
"on_ok",
")",
"return",
"d"
] | Informs the DBus daemon of the process's interest in the specified
signal and registers the callback function to be called when the
signal arrives. Multiple callbacks may be registered.
@type signalName: C{string}
@param signalName: Name of the signal to register the callback for
@type callback: Callable object
@param callback: Callback to be called on signal arrival. The callback
will be passed signals arguments as positional function arguments.
@type interface: C{string}
@param interface: Optional DBus interface emitting the signal. This is
only needed if more than one interface shares a signal with the
same name
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to an integer rule_id that may be passed to
cancelSignalNotification to prevent the delivery of future signals
to the callback | [
"Informs",
"the",
"DBus",
"daemon",
"of",
"the",
"process",
"s",
"interest",
"in",
"the",
"specified",
"signal",
"and",
"registers",
"the",
"callback",
"function",
"to",
"be",
"called",
"when",
"the",
"signal",
"arrives",
".",
"Multiple",
"callbacks",
"may",
"be",
"registered",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L144-L211 |
cocagne/txdbus | txdbus/objects.py | RemoteDBusObject.cancelSignalNotification | def cancelSignalNotification(self, rule_id):
"""
Cancels a callback previously registered with notifyOnSignal
"""
if self._signalRules and rule_id in self._signalRules:
self.objHandler.conn.delMatch(rule_id)
self._signalRules.remove(rule_id) | python | def cancelSignalNotification(self, rule_id):
"""
Cancels a callback previously registered with notifyOnSignal
"""
if self._signalRules and rule_id in self._signalRules:
self.objHandler.conn.delMatch(rule_id)
self._signalRules.remove(rule_id) | [
"def",
"cancelSignalNotification",
"(",
"self",
",",
"rule_id",
")",
":",
"if",
"self",
".",
"_signalRules",
"and",
"rule_id",
"in",
"self",
".",
"_signalRules",
":",
"self",
".",
"objHandler",
".",
"conn",
".",
"delMatch",
"(",
"rule_id",
")",
"self",
".",
"_signalRules",
".",
"remove",
"(",
"rule_id",
")"
] | Cancels a callback previously registered with notifyOnSignal | [
"Cancels",
"a",
"callback",
"previously",
"registered",
"with",
"notifyOnSignal"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L213-L219 |
cocagne/txdbus | txdbus/objects.py | RemoteDBusObject.callRemote | def callRemote(self, methodName, *args, **kwargs):
"""
Calls the remote method and returns a Deferred instance to the result.
DBus does not support passing keyword arguments over the wire. The
keyword arguments accepted by this method alter the behavior of the
remote call as described in the kwargs prameter description.
@type methodName: C{string}
@param methodName: Name of the method to call
@param args: Positional arguments to be passed to the remote method
@param kwargs: Three keyword parameters may be passed to alter the
behavior of the remote method call. If \"expectReply=False\" is
supplied, the returned Deferred will be immediately called back
with the value None. If \"autoStart=False\" is supplied the DBus
daemon will not attempt to auto-start a service to fulfill the call
if the service is not yet running (defaults to True). If
\"timeout=VALUE\" is supplied, the returned Deferred will be
errbacked with a L{error.TimeOut} instance if the remote call does
not return before the timeout elapses. If \"interface\" is
specified, the remote call use the method of the named interface.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote call
"""
expectReply = kwargs.get('expectReply', True)
autoStart = kwargs.get('autoStart', True)
timeout = kwargs.get('timeout', None)
interface = kwargs.get('interface', None)
m = None
for i in self.interfaces:
if interface and not interface == i.name:
continue
m = i.methods.get(methodName, None)
if m:
break
if m is None:
raise AttributeError(
'Requested method "%s" is not a member of any of the '
'supported interfaces' % (methodName,),
)
if len(args) != m.nargs:
raise TypeError(
'%s.%s takes %d arguments (%d given)' %
(i.name, methodName, m.nargs, len(args)),
)
return self.objHandler.conn.callRemote(
self.objectPath, methodName,
interface=i.name,
destination=self.busName,
signature=m.sigIn,
body=args,
expectReply=expectReply,
autoStart=autoStart,
timeout=timeout,
returnSignature=m.sigOut,
) | python | def callRemote(self, methodName, *args, **kwargs):
"""
Calls the remote method and returns a Deferred instance to the result.
DBus does not support passing keyword arguments over the wire. The
keyword arguments accepted by this method alter the behavior of the
remote call as described in the kwargs prameter description.
@type methodName: C{string}
@param methodName: Name of the method to call
@param args: Positional arguments to be passed to the remote method
@param kwargs: Three keyword parameters may be passed to alter the
behavior of the remote method call. If \"expectReply=False\" is
supplied, the returned Deferred will be immediately called back
with the value None. If \"autoStart=False\" is supplied the DBus
daemon will not attempt to auto-start a service to fulfill the call
if the service is not yet running (defaults to True). If
\"timeout=VALUE\" is supplied, the returned Deferred will be
errbacked with a L{error.TimeOut} instance if the remote call does
not return before the timeout elapses. If \"interface\" is
specified, the remote call use the method of the named interface.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote call
"""
expectReply = kwargs.get('expectReply', True)
autoStart = kwargs.get('autoStart', True)
timeout = kwargs.get('timeout', None)
interface = kwargs.get('interface', None)
m = None
for i in self.interfaces:
if interface and not interface == i.name:
continue
m = i.methods.get(methodName, None)
if m:
break
if m is None:
raise AttributeError(
'Requested method "%s" is not a member of any of the '
'supported interfaces' % (methodName,),
)
if len(args) != m.nargs:
raise TypeError(
'%s.%s takes %d arguments (%d given)' %
(i.name, methodName, m.nargs, len(args)),
)
return self.objHandler.conn.callRemote(
self.objectPath, methodName,
interface=i.name,
destination=self.busName,
signature=m.sigIn,
body=args,
expectReply=expectReply,
autoStart=autoStart,
timeout=timeout,
returnSignature=m.sigOut,
) | [
"def",
"callRemote",
"(",
"self",
",",
"methodName",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"expectReply",
"=",
"kwargs",
".",
"get",
"(",
"'expectReply'",
",",
"True",
")",
"autoStart",
"=",
"kwargs",
".",
"get",
"(",
"'autoStart'",
",",
"True",
")",
"timeout",
"=",
"kwargs",
".",
"get",
"(",
"'timeout'",
",",
"None",
")",
"interface",
"=",
"kwargs",
".",
"get",
"(",
"'interface'",
",",
"None",
")",
"m",
"=",
"None",
"for",
"i",
"in",
"self",
".",
"interfaces",
":",
"if",
"interface",
"and",
"not",
"interface",
"==",
"i",
".",
"name",
":",
"continue",
"m",
"=",
"i",
".",
"methods",
".",
"get",
"(",
"methodName",
",",
"None",
")",
"if",
"m",
":",
"break",
"if",
"m",
"is",
"None",
":",
"raise",
"AttributeError",
"(",
"'Requested method \"%s\" is not a member of any of the '",
"'supported interfaces'",
"%",
"(",
"methodName",
",",
")",
",",
")",
"if",
"len",
"(",
"args",
")",
"!=",
"m",
".",
"nargs",
":",
"raise",
"TypeError",
"(",
"'%s.%s takes %d arguments (%d given)'",
"%",
"(",
"i",
".",
"name",
",",
"methodName",
",",
"m",
".",
"nargs",
",",
"len",
"(",
"args",
")",
")",
",",
")",
"return",
"self",
".",
"objHandler",
".",
"conn",
".",
"callRemote",
"(",
"self",
".",
"objectPath",
",",
"methodName",
",",
"interface",
"=",
"i",
".",
"name",
",",
"destination",
"=",
"self",
".",
"busName",
",",
"signature",
"=",
"m",
".",
"sigIn",
",",
"body",
"=",
"args",
",",
"expectReply",
"=",
"expectReply",
",",
"autoStart",
"=",
"autoStart",
",",
"timeout",
"=",
"timeout",
",",
"returnSignature",
"=",
"m",
".",
"sigOut",
",",
")"
] | Calls the remote method and returns a Deferred instance to the result.
DBus does not support passing keyword arguments over the wire. The
keyword arguments accepted by this method alter the behavior of the
remote call as described in the kwargs prameter description.
@type methodName: C{string}
@param methodName: Name of the method to call
@param args: Positional arguments to be passed to the remote method
@param kwargs: Three keyword parameters may be passed to alter the
behavior of the remote method call. If \"expectReply=False\" is
supplied, the returned Deferred will be immediately called back
with the value None. If \"autoStart=False\" is supplied the DBus
daemon will not attempt to auto-start a service to fulfill the call
if the service is not yet running (defaults to True). If
\"timeout=VALUE\" is supplied, the returned Deferred will be
errbacked with a L{error.TimeOut} instance if the remote call does
not return before the timeout elapses. If \"interface\" is
specified, the remote call use the method of the named interface.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote call | [
"Calls",
"the",
"remote",
"method",
"and",
"returns",
"a",
"Deferred",
"instance",
"to",
"the",
"result",
".",
"DBus",
"does",
"not",
"support",
"passing",
"keyword",
"arguments",
"over",
"the",
"wire",
".",
"The",
"keyword",
"arguments",
"accepted",
"by",
"this",
"method",
"alter",
"the",
"behavior",
"of",
"the",
"remote",
"call",
"as",
"described",
"in",
"the",
"kwargs",
"prameter",
"description",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L221-L283 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler.connectionLost | def connectionLost(self, reason):
"""
Called by the DBus Connection object when the connection is lost.
@type reason: L{twistd.python.failure.Failure}
@param reason: The value passed to the associated connection's
connectionLost method.
"""
for wref in self._weakProxies.valuerefs():
p = wref()
if p is not None:
p.connectionLost(reason) | python | def connectionLost(self, reason):
"""
Called by the DBus Connection object when the connection is lost.
@type reason: L{twistd.python.failure.Failure}
@param reason: The value passed to the associated connection's
connectionLost method.
"""
for wref in self._weakProxies.valuerefs():
p = wref()
if p is not None:
p.connectionLost(reason) | [
"def",
"connectionLost",
"(",
"self",
",",
"reason",
")",
":",
"for",
"wref",
"in",
"self",
".",
"_weakProxies",
".",
"valuerefs",
"(",
")",
":",
"p",
"=",
"wref",
"(",
")",
"if",
"p",
"is",
"not",
"None",
":",
"p",
".",
"connectionLost",
"(",
"reason",
")"
] | Called by the DBus Connection object when the connection is lost.
@type reason: L{twistd.python.failure.Failure}
@param reason: The value passed to the associated connection's
connectionLost method. | [
"Called",
"by",
"the",
"DBus",
"Connection",
"object",
"when",
"the",
"connection",
"is",
"lost",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L649-L660 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler.exportObject | def exportObject(self, dbusObject):
"""
Makes the specified object available over DBus
@type dbusObject: an object implementing the L{IDBusObject} interface
@param dbusObject: The object to export over DBus
"""
o = IDBusObject(dbusObject)
self.exports[o.getObjectPath()] = o
o.setObjectHandler(self)
i = {}
for iface in o.getInterfaces():
i[iface.name] = o.getAllProperties(iface.name)
msig = message.SignalMessage(
o.getObjectPath(),
'InterfacesAdded',
'org.freedesktop.DBus.ObjectManager',
signature='sa{sa{sv}}',
body=[o.getObjectPath(), i],
)
self.conn.sendMessage(msig) | python | def exportObject(self, dbusObject):
"""
Makes the specified object available over DBus
@type dbusObject: an object implementing the L{IDBusObject} interface
@param dbusObject: The object to export over DBus
"""
o = IDBusObject(dbusObject)
self.exports[o.getObjectPath()] = o
o.setObjectHandler(self)
i = {}
for iface in o.getInterfaces():
i[iface.name] = o.getAllProperties(iface.name)
msig = message.SignalMessage(
o.getObjectPath(),
'InterfacesAdded',
'org.freedesktop.DBus.ObjectManager',
signature='sa{sa{sv}}',
body=[o.getObjectPath(), i],
)
self.conn.sendMessage(msig) | [
"def",
"exportObject",
"(",
"self",
",",
"dbusObject",
")",
":",
"o",
"=",
"IDBusObject",
"(",
"dbusObject",
")",
"self",
".",
"exports",
"[",
"o",
".",
"getObjectPath",
"(",
")",
"]",
"=",
"o",
"o",
".",
"setObjectHandler",
"(",
"self",
")",
"i",
"=",
"{",
"}",
"for",
"iface",
"in",
"o",
".",
"getInterfaces",
"(",
")",
":",
"i",
"[",
"iface",
".",
"name",
"]",
"=",
"o",
".",
"getAllProperties",
"(",
"iface",
".",
"name",
")",
"msig",
"=",
"message",
".",
"SignalMessage",
"(",
"o",
".",
"getObjectPath",
"(",
")",
",",
"'InterfacesAdded'",
",",
"'org.freedesktop.DBus.ObjectManager'",
",",
"signature",
"=",
"'sa{sa{sv}}'",
",",
"body",
"=",
"[",
"o",
".",
"getObjectPath",
"(",
")",
",",
"i",
"]",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"msig",
")"
] | Makes the specified object available over DBus
@type dbusObject: an object implementing the L{IDBusObject} interface
@param dbusObject: The object to export over DBus | [
"Makes",
"the",
"specified",
"object",
"available",
"over",
"DBus"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L662-L685 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler.getManagedObjects | def getManagedObjects(self, objectPath):
"""
Returns a Python dictionary containing the reply content for
org.freedesktop.DBus.ObjectManager.GetManagedObjects
"""
d = {}
for p in sorted(self.exports.keys()):
if not p.startswith(objectPath) or p == objectPath:
continue
o = self.exports[p]
i = {}
d[p] = i
for iface in o.getInterfaces():
i[iface.name] = o.getAllProperties(iface.name)
return d | python | def getManagedObjects(self, objectPath):
"""
Returns a Python dictionary containing the reply content for
org.freedesktop.DBus.ObjectManager.GetManagedObjects
"""
d = {}
for p in sorted(self.exports.keys()):
if not p.startswith(objectPath) or p == objectPath:
continue
o = self.exports[p]
i = {}
d[p] = i
for iface in o.getInterfaces():
i[iface.name] = o.getAllProperties(iface.name)
return d | [
"def",
"getManagedObjects",
"(",
"self",
",",
"objectPath",
")",
":",
"d",
"=",
"{",
"}",
"for",
"p",
"in",
"sorted",
"(",
"self",
".",
"exports",
".",
"keys",
"(",
")",
")",
":",
"if",
"not",
"p",
".",
"startswith",
"(",
"objectPath",
")",
"or",
"p",
"==",
"objectPath",
":",
"continue",
"o",
"=",
"self",
".",
"exports",
"[",
"p",
"]",
"i",
"=",
"{",
"}",
"d",
"[",
"p",
"]",
"=",
"i",
"for",
"iface",
"in",
"o",
".",
"getInterfaces",
"(",
")",
":",
"i",
"[",
"iface",
".",
"name",
"]",
"=",
"o",
".",
"getAllProperties",
"(",
"iface",
".",
"name",
")",
"return",
"d"
] | Returns a Python dictionary containing the reply content for
org.freedesktop.DBus.ObjectManager.GetManagedObjects | [
"Returns",
"a",
"Python",
"dictionary",
"containing",
"the",
"reply",
"content",
"for",
"org",
".",
"freedesktop",
".",
"DBus",
".",
"ObjectManager",
".",
"GetManagedObjects"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L708-L724 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler._send_err | def _send_err(self, msg, errName, errMsg):
"""
Helper method for sending error messages
"""
r = message.ErrorMessage(
errName,
msg.serial,
body=[errMsg],
signature='s',
destination=msg.sender,
)
self.conn.sendMessage(r) | python | def _send_err(self, msg, errName, errMsg):
"""
Helper method for sending error messages
"""
r = message.ErrorMessage(
errName,
msg.serial,
body=[errMsg],
signature='s',
destination=msg.sender,
)
self.conn.sendMessage(r) | [
"def",
"_send_err",
"(",
"self",
",",
"msg",
",",
"errName",
",",
"errMsg",
")",
":",
"r",
"=",
"message",
".",
"ErrorMessage",
"(",
"errName",
",",
"msg",
".",
"serial",
",",
"body",
"=",
"[",
"errMsg",
"]",
",",
"signature",
"=",
"'s'",
",",
"destination",
"=",
"msg",
".",
"sender",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")"
] | Helper method for sending error messages | [
"Helper",
"method",
"for",
"sending",
"error",
"messages"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L726-L738 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler.handleMethodCallMessage | def handleMethodCallMessage(self, msg):
"""
Handles DBus MethodCall messages on behalf of the DBus Connection and
dispatches them to the appropriate exported object
"""
if (
msg.interface == 'org.freedesktop.DBus.Peer'
and msg.member == 'Ping'
):
r = message.MethodReturnMessage(
msg.serial,
destination=msg.sender,
)
self.conn.sendMessage(r)
return
if (
msg.interface == 'org.freedesktop.DBus.Introspectable'
and msg.member == 'Introspect'
):
xml = introspection.generateIntrospectionXML(
msg.path,
self.exports,
)
if xml is not None:
r = message.MethodReturnMessage(
msg.serial,
body=[xml],
destination=msg.sender,
signature='s',
)
self.conn.sendMessage(r)
return
# Try to get object from complete object path
o = self.exports.get(msg.path, None)
if o is None:
self._send_err(
msg,
'org.freedesktop.DBus.Error.UnknownObject',
'%s is not an object provided by this process.' % (msg.path),
)
return
if (
msg.interface == 'org.freedesktop.DBus.ObjectManager'
and msg.member == 'GetManagedObjects'
):
i_and_p = self.getManagedObjects(o.getObjectPath())
r = message.MethodReturnMessage(
msg.serial,
body=[i_and_p],
destination=msg.sender,
signature='a{oa{sa{sv}}}',
)
self.conn.sendMessage(r)
return
i = None
for x in o.getInterfaces():
if msg.interface:
if x.name == msg.interface:
i = x
break
else:
if msg.member in x.methods:
i = x
break
m = None
if i:
m = i.methods.get(msg.member, None)
if m is None:
self._send_err(
msg,
'org.freedesktop.DBus.Error.UnknownMethod',
(
'Method "%s" with signature "%s" on interface "%s" '
'doesn\'t exist'
) % (
msg.member, msg.signature or '',
msg.interface or '(null)',
),
)
return
msig = msg.signature if msg.signature is not None else ''
esig = m.sigIn if m.sigIn is not None else ''
if esig != msig:
self._send_err(
msg,
'org.freedesktop.DBus.Error.InvalidArgs',
'Call to %s has wrong args (%s, expected %s)' %
(msg.member, msg.signature or '', m.sigIn or '')
)
return
d = defer.maybeDeferred(
o.executeMethod,
i,
msg.member,
msg.body,
msg.sender,
)
if msg.expectReply:
def send_reply(return_values):
if isinstance(return_values, (list, tuple)):
if m.nret == 1:
return_values = [return_values]
else:
return_values = [return_values]
r = message.MethodReturnMessage(
msg.serial,
body=return_values,
destination=msg.sender,
signature=m.sigOut,
)
self.conn.sendMessage(r)
def send_error(err):
e = err.value
errMsg = err.getErrorMessage()
name = None
if hasattr(e, 'dbusErrorName'):
name = e.dbusErrorName
if name is None:
name = 'org.txdbus.PythonException.' + e.__class__.__name__
try:
marshal.validateErrorName(name)
except error.MarshallingError:
errMsg = ('!!(Invalid error name "%s")!! ' % name) + errMsg
name = 'org.txdbus.InvalidErrorName'
r = message.ErrorMessage(name, msg.serial,
body=[errMsg],
signature='s',
destination=msg.sender)
self.conn.sendMessage(r)
d.addCallback(send_reply)
d.addErrback(send_error) | python | def handleMethodCallMessage(self, msg):
"""
Handles DBus MethodCall messages on behalf of the DBus Connection and
dispatches them to the appropriate exported object
"""
if (
msg.interface == 'org.freedesktop.DBus.Peer'
and msg.member == 'Ping'
):
r = message.MethodReturnMessage(
msg.serial,
destination=msg.sender,
)
self.conn.sendMessage(r)
return
if (
msg.interface == 'org.freedesktop.DBus.Introspectable'
and msg.member == 'Introspect'
):
xml = introspection.generateIntrospectionXML(
msg.path,
self.exports,
)
if xml is not None:
r = message.MethodReturnMessage(
msg.serial,
body=[xml],
destination=msg.sender,
signature='s',
)
self.conn.sendMessage(r)
return
# Try to get object from complete object path
o = self.exports.get(msg.path, None)
if o is None:
self._send_err(
msg,
'org.freedesktop.DBus.Error.UnknownObject',
'%s is not an object provided by this process.' % (msg.path),
)
return
if (
msg.interface == 'org.freedesktop.DBus.ObjectManager'
and msg.member == 'GetManagedObjects'
):
i_and_p = self.getManagedObjects(o.getObjectPath())
r = message.MethodReturnMessage(
msg.serial,
body=[i_and_p],
destination=msg.sender,
signature='a{oa{sa{sv}}}',
)
self.conn.sendMessage(r)
return
i = None
for x in o.getInterfaces():
if msg.interface:
if x.name == msg.interface:
i = x
break
else:
if msg.member in x.methods:
i = x
break
m = None
if i:
m = i.methods.get(msg.member, None)
if m is None:
self._send_err(
msg,
'org.freedesktop.DBus.Error.UnknownMethod',
(
'Method "%s" with signature "%s" on interface "%s" '
'doesn\'t exist'
) % (
msg.member, msg.signature or '',
msg.interface or '(null)',
),
)
return
msig = msg.signature if msg.signature is not None else ''
esig = m.sigIn if m.sigIn is not None else ''
if esig != msig:
self._send_err(
msg,
'org.freedesktop.DBus.Error.InvalidArgs',
'Call to %s has wrong args (%s, expected %s)' %
(msg.member, msg.signature or '', m.sigIn or '')
)
return
d = defer.maybeDeferred(
o.executeMethod,
i,
msg.member,
msg.body,
msg.sender,
)
if msg.expectReply:
def send_reply(return_values):
if isinstance(return_values, (list, tuple)):
if m.nret == 1:
return_values = [return_values]
else:
return_values = [return_values]
r = message.MethodReturnMessage(
msg.serial,
body=return_values,
destination=msg.sender,
signature=m.sigOut,
)
self.conn.sendMessage(r)
def send_error(err):
e = err.value
errMsg = err.getErrorMessage()
name = None
if hasattr(e, 'dbusErrorName'):
name = e.dbusErrorName
if name is None:
name = 'org.txdbus.PythonException.' + e.__class__.__name__
try:
marshal.validateErrorName(name)
except error.MarshallingError:
errMsg = ('!!(Invalid error name "%s")!! ' % name) + errMsg
name = 'org.txdbus.InvalidErrorName'
r = message.ErrorMessage(name, msg.serial,
body=[errMsg],
signature='s',
destination=msg.sender)
self.conn.sendMessage(r)
d.addCallback(send_reply)
d.addErrback(send_error) | [
"def",
"handleMethodCallMessage",
"(",
"self",
",",
"msg",
")",
":",
"if",
"(",
"msg",
".",
"interface",
"==",
"'org.freedesktop.DBus.Peer'",
"and",
"msg",
".",
"member",
"==",
"'Ping'",
")",
":",
"r",
"=",
"message",
".",
"MethodReturnMessage",
"(",
"msg",
".",
"serial",
",",
"destination",
"=",
"msg",
".",
"sender",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")",
"return",
"if",
"(",
"msg",
".",
"interface",
"==",
"'org.freedesktop.DBus.Introspectable'",
"and",
"msg",
".",
"member",
"==",
"'Introspect'",
")",
":",
"xml",
"=",
"introspection",
".",
"generateIntrospectionXML",
"(",
"msg",
".",
"path",
",",
"self",
".",
"exports",
",",
")",
"if",
"xml",
"is",
"not",
"None",
":",
"r",
"=",
"message",
".",
"MethodReturnMessage",
"(",
"msg",
".",
"serial",
",",
"body",
"=",
"[",
"xml",
"]",
",",
"destination",
"=",
"msg",
".",
"sender",
",",
"signature",
"=",
"'s'",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")",
"return",
"# Try to get object from complete object path",
"o",
"=",
"self",
".",
"exports",
".",
"get",
"(",
"msg",
".",
"path",
",",
"None",
")",
"if",
"o",
"is",
"None",
":",
"self",
".",
"_send_err",
"(",
"msg",
",",
"'org.freedesktop.DBus.Error.UnknownObject'",
",",
"'%s is not an object provided by this process.'",
"%",
"(",
"msg",
".",
"path",
")",
",",
")",
"return",
"if",
"(",
"msg",
".",
"interface",
"==",
"'org.freedesktop.DBus.ObjectManager'",
"and",
"msg",
".",
"member",
"==",
"'GetManagedObjects'",
")",
":",
"i_and_p",
"=",
"self",
".",
"getManagedObjects",
"(",
"o",
".",
"getObjectPath",
"(",
")",
")",
"r",
"=",
"message",
".",
"MethodReturnMessage",
"(",
"msg",
".",
"serial",
",",
"body",
"=",
"[",
"i_and_p",
"]",
",",
"destination",
"=",
"msg",
".",
"sender",
",",
"signature",
"=",
"'a{oa{sa{sv}}}'",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")",
"return",
"i",
"=",
"None",
"for",
"x",
"in",
"o",
".",
"getInterfaces",
"(",
")",
":",
"if",
"msg",
".",
"interface",
":",
"if",
"x",
".",
"name",
"==",
"msg",
".",
"interface",
":",
"i",
"=",
"x",
"break",
"else",
":",
"if",
"msg",
".",
"member",
"in",
"x",
".",
"methods",
":",
"i",
"=",
"x",
"break",
"m",
"=",
"None",
"if",
"i",
":",
"m",
"=",
"i",
".",
"methods",
".",
"get",
"(",
"msg",
".",
"member",
",",
"None",
")",
"if",
"m",
"is",
"None",
":",
"self",
".",
"_send_err",
"(",
"msg",
",",
"'org.freedesktop.DBus.Error.UnknownMethod'",
",",
"(",
"'Method \"%s\" with signature \"%s\" on interface \"%s\" '",
"'doesn\\'t exist'",
")",
"%",
"(",
"msg",
".",
"member",
",",
"msg",
".",
"signature",
"or",
"''",
",",
"msg",
".",
"interface",
"or",
"'(null)'",
",",
")",
",",
")",
"return",
"msig",
"=",
"msg",
".",
"signature",
"if",
"msg",
".",
"signature",
"is",
"not",
"None",
"else",
"''",
"esig",
"=",
"m",
".",
"sigIn",
"if",
"m",
".",
"sigIn",
"is",
"not",
"None",
"else",
"''",
"if",
"esig",
"!=",
"msig",
":",
"self",
".",
"_send_err",
"(",
"msg",
",",
"'org.freedesktop.DBus.Error.InvalidArgs'",
",",
"'Call to %s has wrong args (%s, expected %s)'",
"%",
"(",
"msg",
".",
"member",
",",
"msg",
".",
"signature",
"or",
"''",
",",
"m",
".",
"sigIn",
"or",
"''",
")",
")",
"return",
"d",
"=",
"defer",
".",
"maybeDeferred",
"(",
"o",
".",
"executeMethod",
",",
"i",
",",
"msg",
".",
"member",
",",
"msg",
".",
"body",
",",
"msg",
".",
"sender",
",",
")",
"if",
"msg",
".",
"expectReply",
":",
"def",
"send_reply",
"(",
"return_values",
")",
":",
"if",
"isinstance",
"(",
"return_values",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"if",
"m",
".",
"nret",
"==",
"1",
":",
"return_values",
"=",
"[",
"return_values",
"]",
"else",
":",
"return_values",
"=",
"[",
"return_values",
"]",
"r",
"=",
"message",
".",
"MethodReturnMessage",
"(",
"msg",
".",
"serial",
",",
"body",
"=",
"return_values",
",",
"destination",
"=",
"msg",
".",
"sender",
",",
"signature",
"=",
"m",
".",
"sigOut",
",",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")",
"def",
"send_error",
"(",
"err",
")",
":",
"e",
"=",
"err",
".",
"value",
"errMsg",
"=",
"err",
".",
"getErrorMessage",
"(",
")",
"name",
"=",
"None",
"if",
"hasattr",
"(",
"e",
",",
"'dbusErrorName'",
")",
":",
"name",
"=",
"e",
".",
"dbusErrorName",
"if",
"name",
"is",
"None",
":",
"name",
"=",
"'org.txdbus.PythonException.'",
"+",
"e",
".",
"__class__",
".",
"__name__",
"try",
":",
"marshal",
".",
"validateErrorName",
"(",
"name",
")",
"except",
"error",
".",
"MarshallingError",
":",
"errMsg",
"=",
"(",
"'!!(Invalid error name \"%s\")!! '",
"%",
"name",
")",
"+",
"errMsg",
"name",
"=",
"'org.txdbus.InvalidErrorName'",
"r",
"=",
"message",
".",
"ErrorMessage",
"(",
"name",
",",
"msg",
".",
"serial",
",",
"body",
"=",
"[",
"errMsg",
"]",
",",
"signature",
"=",
"'s'",
",",
"destination",
"=",
"msg",
".",
"sender",
")",
"self",
".",
"conn",
".",
"sendMessage",
"(",
"r",
")",
"d",
".",
"addCallback",
"(",
"send_reply",
")",
"d",
".",
"addErrback",
"(",
"send_error",
")"
] | Handles DBus MethodCall messages on behalf of the DBus Connection and
dispatches them to the appropriate exported object | [
"Handles",
"DBus",
"MethodCall",
"messages",
"on",
"behalf",
"of",
"the",
"DBus",
"Connection",
"and",
"dispatches",
"them",
"to",
"the",
"appropriate",
"exported",
"object"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L740-L896 |
cocagne/txdbus | txdbus/objects.py | DBusObjectHandler.getRemoteObject | def getRemoteObject(self, busName, objectPath, interfaces=None,
replaceKnownInterfaces=False):
"""
Creates a L{RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not
supplied, DBus object introspection will be used to obtain
them automatically.
@type busName: C{string}
@param busName: Name of the bus exporting the desired object
@type objectPath: C{string}
@param objectPath: DBus path of the desired object
@type interfaces: None, C{string} or L{interface.DBusInterface} or a
list of C{string}/L{interface.DBusInterface}
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interfacep names, no
introspection will be preformed.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), any
interfaces discovered during the
introspection process will override any
previous, cached values.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A Deferred to the L{RemoteDBusObject} instance
"""
weak_id = (busName, objectPath, interfaces)
need_introspection = False
required_interfaces = set()
if interfaces is not None:
ifl = []
if not isinstance(interfaces, list):
interfaces = [interfaces]
for i in interfaces:
if isinstance(i, interface.DBusInterface):
ifl.append(i)
required_interfaces.add(i.name)
else:
required_interfaces.add(i)
if i in interface.DBusInterface.knownInterfaces:
ifl.append(interface.DBusInterface.knownInterfaces[i])
else:
need_introspection = True
if not need_introspection:
return defer.succeed(
RemoteDBusObject(self, busName, objectPath, ifl)
)
d = self.conn.introspectRemoteObject(
busName,
objectPath,
replaceKnownInterfaces,
)
def ok(ifaces):
missing = required_interfaces - {q.name for q in ifaces}
if missing:
raise error.IntrospectionFailed(
'Introspection failed to find interfaces: '
+ ','.join(missing)
)
prox = RemoteDBusObject(self, busName, objectPath, ifaces)
self._weakProxies[weak_id] = prox
return prox
d.addCallback(ok)
return d | python | def getRemoteObject(self, busName, objectPath, interfaces=None,
replaceKnownInterfaces=False):
"""
Creates a L{RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not
supplied, DBus object introspection will be used to obtain
them automatically.
@type busName: C{string}
@param busName: Name of the bus exporting the desired object
@type objectPath: C{string}
@param objectPath: DBus path of the desired object
@type interfaces: None, C{string} or L{interface.DBusInterface} or a
list of C{string}/L{interface.DBusInterface}
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interfacep names, no
introspection will be preformed.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), any
interfaces discovered during the
introspection process will override any
previous, cached values.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A Deferred to the L{RemoteDBusObject} instance
"""
weak_id = (busName, objectPath, interfaces)
need_introspection = False
required_interfaces = set()
if interfaces is not None:
ifl = []
if not isinstance(interfaces, list):
interfaces = [interfaces]
for i in interfaces:
if isinstance(i, interface.DBusInterface):
ifl.append(i)
required_interfaces.add(i.name)
else:
required_interfaces.add(i)
if i in interface.DBusInterface.knownInterfaces:
ifl.append(interface.DBusInterface.knownInterfaces[i])
else:
need_introspection = True
if not need_introspection:
return defer.succeed(
RemoteDBusObject(self, busName, objectPath, ifl)
)
d = self.conn.introspectRemoteObject(
busName,
objectPath,
replaceKnownInterfaces,
)
def ok(ifaces):
missing = required_interfaces - {q.name for q in ifaces}
if missing:
raise error.IntrospectionFailed(
'Introspection failed to find interfaces: '
+ ','.join(missing)
)
prox = RemoteDBusObject(self, busName, objectPath, ifaces)
self._weakProxies[weak_id] = prox
return prox
d.addCallback(ok)
return d | [
"def",
"getRemoteObject",
"(",
"self",
",",
"busName",
",",
"objectPath",
",",
"interfaces",
"=",
"None",
",",
"replaceKnownInterfaces",
"=",
"False",
")",
":",
"weak_id",
"=",
"(",
"busName",
",",
"objectPath",
",",
"interfaces",
")",
"need_introspection",
"=",
"False",
"required_interfaces",
"=",
"set",
"(",
")",
"if",
"interfaces",
"is",
"not",
"None",
":",
"ifl",
"=",
"[",
"]",
"if",
"not",
"isinstance",
"(",
"interfaces",
",",
"list",
")",
":",
"interfaces",
"=",
"[",
"interfaces",
"]",
"for",
"i",
"in",
"interfaces",
":",
"if",
"isinstance",
"(",
"i",
",",
"interface",
".",
"DBusInterface",
")",
":",
"ifl",
".",
"append",
"(",
"i",
")",
"required_interfaces",
".",
"add",
"(",
"i",
".",
"name",
")",
"else",
":",
"required_interfaces",
".",
"add",
"(",
"i",
")",
"if",
"i",
"in",
"interface",
".",
"DBusInterface",
".",
"knownInterfaces",
":",
"ifl",
".",
"append",
"(",
"interface",
".",
"DBusInterface",
".",
"knownInterfaces",
"[",
"i",
"]",
")",
"else",
":",
"need_introspection",
"=",
"True",
"if",
"not",
"need_introspection",
":",
"return",
"defer",
".",
"succeed",
"(",
"RemoteDBusObject",
"(",
"self",
",",
"busName",
",",
"objectPath",
",",
"ifl",
")",
")",
"d",
"=",
"self",
".",
"conn",
".",
"introspectRemoteObject",
"(",
"busName",
",",
"objectPath",
",",
"replaceKnownInterfaces",
",",
")",
"def",
"ok",
"(",
"ifaces",
")",
":",
"missing",
"=",
"required_interfaces",
"-",
"{",
"q",
".",
"name",
"for",
"q",
"in",
"ifaces",
"}",
"if",
"missing",
":",
"raise",
"error",
".",
"IntrospectionFailed",
"(",
"'Introspection failed to find interfaces: '",
"+",
"','",
".",
"join",
"(",
"missing",
")",
")",
"prox",
"=",
"RemoteDBusObject",
"(",
"self",
",",
"busName",
",",
"objectPath",
",",
"ifaces",
")",
"self",
".",
"_weakProxies",
"[",
"weak_id",
"]",
"=",
"prox",
"return",
"prox",
"d",
".",
"addCallback",
"(",
"ok",
")",
"return",
"d"
] | Creates a L{RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not
supplied, DBus object introspection will be used to obtain
them automatically.
@type busName: C{string}
@param busName: Name of the bus exporting the desired object
@type objectPath: C{string}
@param objectPath: DBus path of the desired object
@type interfaces: None, C{string} or L{interface.DBusInterface} or a
list of C{string}/L{interface.DBusInterface}
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interfacep names, no
introspection will be preformed.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), any
interfaces discovered during the
introspection process will override any
previous, cached values.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A Deferred to the L{RemoteDBusObject} instance | [
"Creates",
"a",
"L",
"{",
"RemoteDBusObject",
"}",
"instance",
"to",
"represent",
"the",
"specified",
"DBus",
"object",
".",
"If",
"explicit",
"interfaces",
"are",
"not",
"supplied",
"DBus",
"object",
"introspection",
"will",
"be",
"used",
"to",
"obtain",
"them",
"automatically",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/objects.py#L898-L984 |
cocagne/txdbus | txdbus/interface.py | DBusInterface.addMethod | def addMethod(self, m):
"""
Adds a L{Method} to the interface
"""
if m.nargs == -1:
m.nargs = len([a for a in marshal.genCompleteTypes(m.sigIn)])
m.nret = len([a for a in marshal.genCompleteTypes(m.sigOut)])
self.methods[m.name] = m
self._xml = None | python | def addMethod(self, m):
"""
Adds a L{Method} to the interface
"""
if m.nargs == -1:
m.nargs = len([a for a in marshal.genCompleteTypes(m.sigIn)])
m.nret = len([a for a in marshal.genCompleteTypes(m.sigOut)])
self.methods[m.name] = m
self._xml = None | [
"def",
"addMethod",
"(",
"self",
",",
"m",
")",
":",
"if",
"m",
".",
"nargs",
"==",
"-",
"1",
":",
"m",
".",
"nargs",
"=",
"len",
"(",
"[",
"a",
"for",
"a",
"in",
"marshal",
".",
"genCompleteTypes",
"(",
"m",
".",
"sigIn",
")",
"]",
")",
"m",
".",
"nret",
"=",
"len",
"(",
"[",
"a",
"for",
"a",
"in",
"marshal",
".",
"genCompleteTypes",
"(",
"m",
".",
"sigOut",
")",
"]",
")",
"self",
".",
"methods",
"[",
"m",
".",
"name",
"]",
"=",
"m",
"self",
".",
"_xml",
"=",
"None"
] | Adds a L{Method} to the interface | [
"Adds",
"a",
"L",
"{",
"Method",
"}",
"to",
"the",
"interface"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/interface.py#L162-L170 |
cocagne/txdbus | txdbus/interface.py | DBusInterface.addSignal | def addSignal(self, s):
"""
Adds a L{Signal} to the interface
"""
if s.nargs == -1:
s.nargs = len([a for a in marshal.genCompleteTypes(s.sig)])
self.signals[s.name] = s
self._xml = None | python | def addSignal(self, s):
"""
Adds a L{Signal} to the interface
"""
if s.nargs == -1:
s.nargs = len([a for a in marshal.genCompleteTypes(s.sig)])
self.signals[s.name] = s
self._xml = None | [
"def",
"addSignal",
"(",
"self",
",",
"s",
")",
":",
"if",
"s",
".",
"nargs",
"==",
"-",
"1",
":",
"s",
".",
"nargs",
"=",
"len",
"(",
"[",
"a",
"for",
"a",
"in",
"marshal",
".",
"genCompleteTypes",
"(",
"s",
".",
"sig",
")",
"]",
")",
"self",
".",
"signals",
"[",
"s",
".",
"name",
"]",
"=",
"s",
"self",
".",
"_xml",
"=",
"None"
] | Adds a L{Signal} to the interface | [
"Adds",
"a",
"L",
"{",
"Signal",
"}",
"to",
"the",
"interface"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/interface.py#L172-L179 |
cocagne/txdbus | txdbus/client.py | connect | def connect(reactor, busAddress='session'):
"""
Connects to the specified bus and returns a
L{twisted.internet.defer.Deferred} to the fully-connected
L{DBusClientConnection}.
@param reactor: L{twisted.internet.interfaces.IReactor} implementor
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: L{DBusClientConnection}
@returns: Deferred to L{DBusClientConnection}
"""
from txdbus import endpoints
f = DBusClientFactory()
d = f.getConnection()
eplist = endpoints.getDBusEndpoints(reactor, busAddress)
eplist.reverse()
def try_next_ep(err):
if eplist:
eplist.pop().connect(f).addErrback(try_next_ep)
else:
d.errback(
ConnectError(
string=(
'Failed to connect to any bus address. Last error: '
+ err.getErrorMessage()
)
)
)
if eplist:
try_next_ep(None)
else:
d.errback(
ConnectError(
string=(
'Failed to connect to any bus address. No valid bus '
'addresses found'
)
)
)
return d | python | def connect(reactor, busAddress='session'):
"""
Connects to the specified bus and returns a
L{twisted.internet.defer.Deferred} to the fully-connected
L{DBusClientConnection}.
@param reactor: L{twisted.internet.interfaces.IReactor} implementor
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: L{DBusClientConnection}
@returns: Deferred to L{DBusClientConnection}
"""
from txdbus import endpoints
f = DBusClientFactory()
d = f.getConnection()
eplist = endpoints.getDBusEndpoints(reactor, busAddress)
eplist.reverse()
def try_next_ep(err):
if eplist:
eplist.pop().connect(f).addErrback(try_next_ep)
else:
d.errback(
ConnectError(
string=(
'Failed to connect to any bus address. Last error: '
+ err.getErrorMessage()
)
)
)
if eplist:
try_next_ep(None)
else:
d.errback(
ConnectError(
string=(
'Failed to connect to any bus address. No valid bus '
'addresses found'
)
)
)
return d | [
"def",
"connect",
"(",
"reactor",
",",
"busAddress",
"=",
"'session'",
")",
":",
"from",
"txdbus",
"import",
"endpoints",
"f",
"=",
"DBusClientFactory",
"(",
")",
"d",
"=",
"f",
".",
"getConnection",
"(",
")",
"eplist",
"=",
"endpoints",
".",
"getDBusEndpoints",
"(",
"reactor",
",",
"busAddress",
")",
"eplist",
".",
"reverse",
"(",
")",
"def",
"try_next_ep",
"(",
"err",
")",
":",
"if",
"eplist",
":",
"eplist",
".",
"pop",
"(",
")",
".",
"connect",
"(",
"f",
")",
".",
"addErrback",
"(",
"try_next_ep",
")",
"else",
":",
"d",
".",
"errback",
"(",
"ConnectError",
"(",
"string",
"=",
"(",
"'Failed to connect to any bus address. Last error: '",
"+",
"err",
".",
"getErrorMessage",
"(",
")",
")",
")",
")",
"if",
"eplist",
":",
"try_next_ep",
"(",
"None",
")",
"else",
":",
"d",
".",
"errback",
"(",
"ConnectError",
"(",
"string",
"=",
"(",
"'Failed to connect to any bus address. No valid bus '",
"'addresses found'",
")",
")",
")",
"return",
"d"
] | Connects to the specified bus and returns a
L{twisted.internet.defer.Deferred} to the fully-connected
L{DBusClientConnection}.
@param reactor: L{twisted.internet.interfaces.IReactor} implementor
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: L{DBusClientConnection}
@returns: Deferred to L{DBusClientConnection} | [
"Connects",
"to",
"the",
"specified",
"bus",
"and",
"returns",
"a",
"L",
"{",
"twisted",
".",
"internet",
".",
"defer",
".",
"Deferred",
"}",
"to",
"the",
"fully",
"-",
"connected",
"L",
"{",
"DBusClientConnection",
"}",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L671-L726 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.connectionAuthenticated | def connectionAuthenticated(self):
"""
Called by L{protocol.BasicDBusProtocol} when the DBus authentication
has completed successfully.
"""
self.router = router.MessageRouter()
self.match_rules = {}
self.objHandler = objects.DBusObjectHandler(self)
# serial_number => (deferred, delayed_timeout_cb | None):
self._pendingCalls = {}
self._dcCallbacks = []
d = self.callRemote(
'/Hello',
'Hello',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
)
d.addCallbacks(
self._cbGotHello,
lambda err: self.factory._failed(err),
) | python | def connectionAuthenticated(self):
"""
Called by L{protocol.BasicDBusProtocol} when the DBus authentication
has completed successfully.
"""
self.router = router.MessageRouter()
self.match_rules = {}
self.objHandler = objects.DBusObjectHandler(self)
# serial_number => (deferred, delayed_timeout_cb | None):
self._pendingCalls = {}
self._dcCallbacks = []
d = self.callRemote(
'/Hello',
'Hello',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
)
d.addCallbacks(
self._cbGotHello,
lambda err: self.factory._failed(err),
) | [
"def",
"connectionAuthenticated",
"(",
"self",
")",
":",
"self",
".",
"router",
"=",
"router",
".",
"MessageRouter",
"(",
")",
"self",
".",
"match_rules",
"=",
"{",
"}",
"self",
".",
"objHandler",
"=",
"objects",
".",
"DBusObjectHandler",
"(",
"self",
")",
"# serial_number => (deferred, delayed_timeout_cb | None):",
"self",
".",
"_pendingCalls",
"=",
"{",
"}",
"self",
".",
"_dcCallbacks",
"=",
"[",
"]",
"d",
"=",
"self",
".",
"callRemote",
"(",
"'/Hello'",
",",
"'Hello'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
",",
"destination",
"=",
"'org.freedesktop.DBus'",
",",
")",
"d",
".",
"addCallbacks",
"(",
"self",
".",
"_cbGotHello",
",",
"lambda",
"err",
":",
"self",
".",
"factory",
".",
"_failed",
"(",
"err",
")",
",",
")"
] | Called by L{protocol.BasicDBusProtocol} when the DBus authentication
has completed successfully. | [
"Called",
"by",
"L",
"{",
"protocol",
".",
"BasicDBusProtocol",
"}",
"when",
"the",
"DBus",
"authentication",
"has",
"completed",
"successfully",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L57-L79 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection._cbGotHello | def _cbGotHello(self, busName):
"""
Called in reply to the initial Hello remote method invocation
"""
self.busName = busName
# print 'Connection Bus Name = ', self.busName
self.factory._ok(self) | python | def _cbGotHello(self, busName):
"""
Called in reply to the initial Hello remote method invocation
"""
self.busName = busName
# print 'Connection Bus Name = ', self.busName
self.factory._ok(self) | [
"def",
"_cbGotHello",
"(",
"self",
",",
"busName",
")",
":",
"self",
".",
"busName",
"=",
"busName",
"# print 'Connection Bus Name = ', self.busName",
"self",
".",
"factory",
".",
"_ok",
"(",
"self",
")"
] | Called in reply to the initial Hello remote method invocation | [
"Called",
"in",
"reply",
"to",
"the",
"initial",
"Hello",
"remote",
"method",
"invocation"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L81-L89 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.connectionLost | def connectionLost(self, reason):
"""
Called when the transport loses connection to the bus
"""
if self.busName is None:
return
for cb in self._dcCallbacks:
cb(self, reason)
for d, timeout in self._pendingCalls.values():
if timeout:
timeout.cancel()
d.errback(reason)
self._pendingCalls = {}
self.objHandler.connectionLost(reason) | python | def connectionLost(self, reason):
"""
Called when the transport loses connection to the bus
"""
if self.busName is None:
return
for cb in self._dcCallbacks:
cb(self, reason)
for d, timeout in self._pendingCalls.values():
if timeout:
timeout.cancel()
d.errback(reason)
self._pendingCalls = {}
self.objHandler.connectionLost(reason) | [
"def",
"connectionLost",
"(",
"self",
",",
"reason",
")",
":",
"if",
"self",
".",
"busName",
"is",
"None",
":",
"return",
"for",
"cb",
"in",
"self",
".",
"_dcCallbacks",
":",
"cb",
"(",
"self",
",",
"reason",
")",
"for",
"d",
",",
"timeout",
"in",
"self",
".",
"_pendingCalls",
".",
"values",
"(",
")",
":",
"if",
"timeout",
":",
"timeout",
".",
"cancel",
"(",
")",
"d",
".",
"errback",
"(",
"reason",
")",
"self",
".",
"_pendingCalls",
"=",
"{",
"}",
"self",
".",
"objHandler",
".",
"connectionLost",
"(",
"reason",
")"
] | Called when the transport loses connection to the bus | [
"Called",
"when",
"the",
"transport",
"loses",
"connection",
"to",
"the",
"bus"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L97-L113 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.getRemoteObject | def getRemoteObject(self, busName, objectPath, interfaces=None,
replaceKnownInterfaces=False):
"""
Creates a L{objects.RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not supplied, DBus
object introspection will be used to obtain them automatically.
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interface names, no
introspection will be preformed.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A deferred to a L{objects.RemoteDBusObject} instance
representing the remote object
"""
return self.objHandler.getRemoteObject(
busName,
objectPath,
interfaces,
replaceKnownInterfaces,
) | python | def getRemoteObject(self, busName, objectPath, interfaces=None,
replaceKnownInterfaces=False):
"""
Creates a L{objects.RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not supplied, DBus
object introspection will be used to obtain them automatically.
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interface names, no
introspection will be preformed.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A deferred to a L{objects.RemoteDBusObject} instance
representing the remote object
"""
return self.objHandler.getRemoteObject(
busName,
objectPath,
interfaces,
replaceKnownInterfaces,
) | [
"def",
"getRemoteObject",
"(",
"self",
",",
"busName",
",",
"objectPath",
",",
"interfaces",
"=",
"None",
",",
"replaceKnownInterfaces",
"=",
"False",
")",
":",
"return",
"self",
".",
"objHandler",
".",
"getRemoteObject",
"(",
"busName",
",",
"objectPath",
",",
"interfaces",
",",
"replaceKnownInterfaces",
",",
")"
] | Creates a L{objects.RemoteDBusObject} instance to represent the
specified DBus object. If explicit interfaces are not supplied, DBus
object introspection will be used to obtain them automatically.
@param interfaces: May be None, a single value, or a list of string
interface names and/or instances of
L{interface.DBusInterface}. If None or any of the
specified interface names are unknown, full
introspection will be attempted. If interfaces
consists of solely of L{interface.DBusInterface}
instances and/or known interface names, no
introspection will be preformed.
@rtype: L{twisted.internet.defer.Deferred}
@returns: A deferred to a L{objects.RemoteDBusObject} instance
representing the remote object | [
"Creates",
"a",
"L",
"{",
"objects",
".",
"RemoteDBusObject",
"}",
"instance",
"to",
"represent",
"the",
"specified",
"DBus",
"object",
".",
"If",
"explicit",
"interfaces",
"are",
"not",
"supplied",
"DBus",
"object",
"introspection",
"will",
"be",
"used",
"to",
"obtain",
"them",
"automatically",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L153-L178 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.delMatch | def delMatch(self, rule_id):
"""
Removes a message matching rule previously registered with addMatch
"""
rule = self.match_rules[rule_id]
d = self.callRemote(
'/org/freedesktop/DBus',
'RemoveMatch',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
body=[rule],
signature='s',
)
def ok(_):
del self.match_rules[rule_id]
self.router.delMatch(rule_id)
d.addCallback(ok)
return d | python | def delMatch(self, rule_id):
"""
Removes a message matching rule previously registered with addMatch
"""
rule = self.match_rules[rule_id]
d = self.callRemote(
'/org/freedesktop/DBus',
'RemoveMatch',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
body=[rule],
signature='s',
)
def ok(_):
del self.match_rules[rule_id]
self.router.delMatch(rule_id)
d.addCallback(ok)
return d | [
"def",
"delMatch",
"(",
"self",
",",
"rule_id",
")",
":",
"rule",
"=",
"self",
".",
"match_rules",
"[",
"rule_id",
"]",
"d",
"=",
"self",
".",
"callRemote",
"(",
"'/org/freedesktop/DBus'",
",",
"'RemoveMatch'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
",",
"destination",
"=",
"'org.freedesktop.DBus'",
",",
"body",
"=",
"[",
"rule",
"]",
",",
"signature",
"=",
"'s'",
",",
")",
"def",
"ok",
"(",
"_",
")",
":",
"del",
"self",
".",
"match_rules",
"[",
"rule_id",
"]",
"self",
".",
"router",
".",
"delMatch",
"(",
"rule_id",
")",
"d",
".",
"addCallback",
"(",
"ok",
")",
"return",
"d"
] | Removes a message matching rule previously registered with addMatch | [
"Removes",
"a",
"message",
"matching",
"rule",
"previously",
"registered",
"with",
"addMatch"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L180-L201 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.addMatch | def addMatch(self, callback, mtype=None, sender=None, interface=None,
member=None, path=None, path_namespace=None, destination=None,
arg=None, arg_path=None, arg0namespace=None):
"""
Creates a message matching rule, associates it with the specified
callback function, and sends the match rule to the DBus daemon.
The arguments to this function are exactly follow the DBus
specification. Refer to the \"Message Bus Message Routing\" section of
the DBus specification for details.
@rtype: C{int}
@returns: a L{Deferred} to an integer id that may be used to unregister
the match rule
"""
l = []
def add(k, v):
if v is not None:
l.append("%s='%s'" % (k, v))
add('type', mtype)
add('sender', sender)
add('interface', interface)
add('member', member)
add('path', path)
add('path_namespace', path_namespace)
add('destination', destination)
if arg:
for idx, v in arg:
add('arg%d' % (idx,), v)
if arg_path:
for idx, v in arg_path:
add('arg%dpath' % (idx,), v)
add('arg0namespace', arg0namespace)
rule = ','.join(l)
d = self.callRemote(
'/org/freedesktop/DBus',
'AddMatch',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
body=[rule],
signature='s',
)
def ok(_):
rule_id = self.router.addMatch(
callback,
mtype,
sender,
interface,
member,
path,
path_namespace,
destination,
arg,
arg_path,
arg0namespace,
)
self.match_rules[rule_id] = rule
return rule_id
d.addCallbacks(ok)
return d | python | def addMatch(self, callback, mtype=None, sender=None, interface=None,
member=None, path=None, path_namespace=None, destination=None,
arg=None, arg_path=None, arg0namespace=None):
"""
Creates a message matching rule, associates it with the specified
callback function, and sends the match rule to the DBus daemon.
The arguments to this function are exactly follow the DBus
specification. Refer to the \"Message Bus Message Routing\" section of
the DBus specification for details.
@rtype: C{int}
@returns: a L{Deferred} to an integer id that may be used to unregister
the match rule
"""
l = []
def add(k, v):
if v is not None:
l.append("%s='%s'" % (k, v))
add('type', mtype)
add('sender', sender)
add('interface', interface)
add('member', member)
add('path', path)
add('path_namespace', path_namespace)
add('destination', destination)
if arg:
for idx, v in arg:
add('arg%d' % (idx,), v)
if arg_path:
for idx, v in arg_path:
add('arg%dpath' % (idx,), v)
add('arg0namespace', arg0namespace)
rule = ','.join(l)
d = self.callRemote(
'/org/freedesktop/DBus',
'AddMatch',
interface='org.freedesktop.DBus',
destination='org.freedesktop.DBus',
body=[rule],
signature='s',
)
def ok(_):
rule_id = self.router.addMatch(
callback,
mtype,
sender,
interface,
member,
path,
path_namespace,
destination,
arg,
arg_path,
arg0namespace,
)
self.match_rules[rule_id] = rule
return rule_id
d.addCallbacks(ok)
return d | [
"def",
"addMatch",
"(",
"self",
",",
"callback",
",",
"mtype",
"=",
"None",
",",
"sender",
"=",
"None",
",",
"interface",
"=",
"None",
",",
"member",
"=",
"None",
",",
"path",
"=",
"None",
",",
"path_namespace",
"=",
"None",
",",
"destination",
"=",
"None",
",",
"arg",
"=",
"None",
",",
"arg_path",
"=",
"None",
",",
"arg0namespace",
"=",
"None",
")",
":",
"l",
"=",
"[",
"]",
"def",
"add",
"(",
"k",
",",
"v",
")",
":",
"if",
"v",
"is",
"not",
"None",
":",
"l",
".",
"append",
"(",
"\"%s='%s'\"",
"%",
"(",
"k",
",",
"v",
")",
")",
"add",
"(",
"'type'",
",",
"mtype",
")",
"add",
"(",
"'sender'",
",",
"sender",
")",
"add",
"(",
"'interface'",
",",
"interface",
")",
"add",
"(",
"'member'",
",",
"member",
")",
"add",
"(",
"'path'",
",",
"path",
")",
"add",
"(",
"'path_namespace'",
",",
"path_namespace",
")",
"add",
"(",
"'destination'",
",",
"destination",
")",
"if",
"arg",
":",
"for",
"idx",
",",
"v",
"in",
"arg",
":",
"add",
"(",
"'arg%d'",
"%",
"(",
"idx",
",",
")",
",",
"v",
")",
"if",
"arg_path",
":",
"for",
"idx",
",",
"v",
"in",
"arg_path",
":",
"add",
"(",
"'arg%dpath'",
"%",
"(",
"idx",
",",
")",
",",
"v",
")",
"add",
"(",
"'arg0namespace'",
",",
"arg0namespace",
")",
"rule",
"=",
"','",
".",
"join",
"(",
"l",
")",
"d",
"=",
"self",
".",
"callRemote",
"(",
"'/org/freedesktop/DBus'",
",",
"'AddMatch'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
",",
"destination",
"=",
"'org.freedesktop.DBus'",
",",
"body",
"=",
"[",
"rule",
"]",
",",
"signature",
"=",
"'s'",
",",
")",
"def",
"ok",
"(",
"_",
")",
":",
"rule_id",
"=",
"self",
".",
"router",
".",
"addMatch",
"(",
"callback",
",",
"mtype",
",",
"sender",
",",
"interface",
",",
"member",
",",
"path",
",",
"path_namespace",
",",
"destination",
",",
"arg",
",",
"arg_path",
",",
"arg0namespace",
",",
")",
"self",
".",
"match_rules",
"[",
"rule_id",
"]",
"=",
"rule",
"return",
"rule_id",
"d",
".",
"addCallbacks",
"(",
"ok",
")",
"return",
"d"
] | Creates a message matching rule, associates it with the specified
callback function, and sends the match rule to the DBus daemon.
The arguments to this function are exactly follow the DBus
specification. Refer to the \"Message Bus Message Routing\" section of
the DBus specification for details.
@rtype: C{int}
@returns: a L{Deferred} to an integer id that may be used to unregister
the match rule | [
"Creates",
"a",
"message",
"matching",
"rule",
"associates",
"it",
"with",
"the",
"specified",
"callback",
"function",
"and",
"sends",
"the",
"match",
"rule",
"to",
"the",
"DBus",
"daemon",
".",
"The",
"arguments",
"to",
"this",
"function",
"are",
"exactly",
"follow",
"the",
"DBus",
"specification",
".",
"Refer",
"to",
"the",
"\\",
"Message",
"Bus",
"Message",
"Routing",
"\\",
"section",
"of",
"the",
"DBus",
"specification",
"for",
"details",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L203-L272 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.getNameOwner | def getNameOwner(self, busName):
"""
Calls org.freedesktop.DBus.GetNameOwner
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the unique connection name owning the bus name
"""
d = self.callRemote(
'/org/freedesktop/DBus',
'GetNameOwner',
interface='org.freedesktop.DBus',
signature='s',
body=[busName],
destination='org.freedesktop.DBus',
)
return d | python | def getNameOwner(self, busName):
"""
Calls org.freedesktop.DBus.GetNameOwner
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the unique connection name owning the bus name
"""
d = self.callRemote(
'/org/freedesktop/DBus',
'GetNameOwner',
interface='org.freedesktop.DBus',
signature='s',
body=[busName],
destination='org.freedesktop.DBus',
)
return d | [
"def",
"getNameOwner",
"(",
"self",
",",
"busName",
")",
":",
"d",
"=",
"self",
".",
"callRemote",
"(",
"'/org/freedesktop/DBus'",
",",
"'GetNameOwner'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
",",
"signature",
"=",
"'s'",
",",
"body",
"=",
"[",
"busName",
"]",
",",
"destination",
"=",
"'org.freedesktop.DBus'",
",",
")",
"return",
"d"
] | Calls org.freedesktop.DBus.GetNameOwner
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the unique connection name owning the bus name | [
"Calls",
"org",
".",
"freedesktop",
".",
"DBus",
".",
"GetNameOwner"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L274-L288 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.requestBusName | def requestBusName(self, newName,
allowReplacement=False,
replaceExisting=False,
doNotQueue=True,
errbackUnlessAcquired=True):
"""
Calls org.freedesktop.DBus.RequestName to request that the specified
bus name be associated with the connection.
@type newName: C{string}
@param newName: Bus name to acquire
@type allowReplacement: C{bool}
@param allowReplacement: If True (defaults to False) and another
application later requests this same name, the new requester will
be given the name and this connection will lose ownership.
@type replaceExisting: C{bool}
@param replaceExisting: If True (defaults to False) and another
application owns the name but specified allowReplacement at the
time of the name acquisition, this connection will assume ownership
of the bus name.
@type doNotQueue: C{bool}
@param doNotQueue: If True (defaults to True) the name request will
fail if the name is currently in use. If False, the request will
cause this connection to be queued for ownership of the requested
name
@type errbackUnlessAcquired: C{bool}
@param errbackUnlessAcquired: If True (defaults to True) an
L{twisted.python.failure.Failure} will be returned if the name is
not acquired.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to
"""
flags = 0
if allowReplacement:
flags |= 0x1
if replaceExisting:
flags |= 0x2
if doNotQueue:
flags |= 0x4
d = self.callRemote(
'/org/freedesktop/DBus',
'RequestName',
interface='org.freedesktop.DBus',
signature='su',
body=[newName, flags],
destination='org.freedesktop.DBus',
)
def on_result(r):
if errbackUnlessAcquired and not (
r == NAME_ACQUIRED or r == NAME_ALREADY_OWNER):
raise error.FailedToAcquireName(newName, r)
return r
d.addCallback(on_result)
return d | python | def requestBusName(self, newName,
allowReplacement=False,
replaceExisting=False,
doNotQueue=True,
errbackUnlessAcquired=True):
"""
Calls org.freedesktop.DBus.RequestName to request that the specified
bus name be associated with the connection.
@type newName: C{string}
@param newName: Bus name to acquire
@type allowReplacement: C{bool}
@param allowReplacement: If True (defaults to False) and another
application later requests this same name, the new requester will
be given the name and this connection will lose ownership.
@type replaceExisting: C{bool}
@param replaceExisting: If True (defaults to False) and another
application owns the name but specified allowReplacement at the
time of the name acquisition, this connection will assume ownership
of the bus name.
@type doNotQueue: C{bool}
@param doNotQueue: If True (defaults to True) the name request will
fail if the name is currently in use. If False, the request will
cause this connection to be queued for ownership of the requested
name
@type errbackUnlessAcquired: C{bool}
@param errbackUnlessAcquired: If True (defaults to True) an
L{twisted.python.failure.Failure} will be returned if the name is
not acquired.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to
"""
flags = 0
if allowReplacement:
flags |= 0x1
if replaceExisting:
flags |= 0x2
if doNotQueue:
flags |= 0x4
d = self.callRemote(
'/org/freedesktop/DBus',
'RequestName',
interface='org.freedesktop.DBus',
signature='su',
body=[newName, flags],
destination='org.freedesktop.DBus',
)
def on_result(r):
if errbackUnlessAcquired and not (
r == NAME_ACQUIRED or r == NAME_ALREADY_OWNER):
raise error.FailedToAcquireName(newName, r)
return r
d.addCallback(on_result)
return d | [
"def",
"requestBusName",
"(",
"self",
",",
"newName",
",",
"allowReplacement",
"=",
"False",
",",
"replaceExisting",
"=",
"False",
",",
"doNotQueue",
"=",
"True",
",",
"errbackUnlessAcquired",
"=",
"True",
")",
":",
"flags",
"=",
"0",
"if",
"allowReplacement",
":",
"flags",
"|=",
"0x1",
"if",
"replaceExisting",
":",
"flags",
"|=",
"0x2",
"if",
"doNotQueue",
":",
"flags",
"|=",
"0x4",
"d",
"=",
"self",
".",
"callRemote",
"(",
"'/org/freedesktop/DBus'",
",",
"'RequestName'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
",",
"signature",
"=",
"'su'",
",",
"body",
"=",
"[",
"newName",
",",
"flags",
"]",
",",
"destination",
"=",
"'org.freedesktop.DBus'",
",",
")",
"def",
"on_result",
"(",
"r",
")",
":",
"if",
"errbackUnlessAcquired",
"and",
"not",
"(",
"r",
"==",
"NAME_ACQUIRED",
"or",
"r",
"==",
"NAME_ALREADY_OWNER",
")",
":",
"raise",
"error",
".",
"FailedToAcquireName",
"(",
"newName",
",",
"r",
")",
"return",
"r",
"d",
".",
"addCallback",
"(",
"on_result",
")",
"return",
"d"
] | Calls org.freedesktop.DBus.RequestName to request that the specified
bus name be associated with the connection.
@type newName: C{string}
@param newName: Bus name to acquire
@type allowReplacement: C{bool}
@param allowReplacement: If True (defaults to False) and another
application later requests this same name, the new requester will
be given the name and this connection will lose ownership.
@type replaceExisting: C{bool}
@param replaceExisting: If True (defaults to False) and another
application owns the name but specified allowReplacement at the
time of the name acquisition, this connection will assume ownership
of the bus name.
@type doNotQueue: C{bool}
@param doNotQueue: If True (defaults to True) the name request will
fail if the name is currently in use. If False, the request will
cause this connection to be queued for ownership of the requested
name
@type errbackUnlessAcquired: C{bool}
@param errbackUnlessAcquired: If True (defaults to True) an
L{twisted.python.failure.Failure} will be returned if the name is
not acquired.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to | [
"Calls",
"org",
".",
"freedesktop",
".",
"DBus",
".",
"RequestName",
"to",
"request",
"that",
"the",
"specified",
"bus",
"name",
"be",
"associated",
"with",
"the",
"connection",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L342-L404 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.introspectRemoteObject | def introspectRemoteObject(self, busName, objectPath,
replaceKnownInterfaces=False):
"""
Calls org.freedesktop.DBus.Introspectable.Introspect
@type busName: C{string}
@param busName: Name of the bus containing the object
@type objectPath: C{string}
@param objectPath: Object Path to introspect
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), the content
of the introspected XML will override any pre-existing definitions
of the contained interfaces.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to a list of L{interface.DBusInterface} instances
created from the content of the introspected XML description of the
object's interface.
"""
d = self.callRemote(
objectPath,
'Introspect',
interface='org.freedesktop.DBus.Introspectable',
destination=busName,
)
def ok(xml_str):
return introspection.getInterfacesFromXML(
xml_str,
replaceKnownInterfaces
)
def err(e):
raise error.IntrospectionFailed(
'Introspection Failed: ' + e.getErrorMessage()
)
d.addCallbacks(ok, err)
return d | python | def introspectRemoteObject(self, busName, objectPath,
replaceKnownInterfaces=False):
"""
Calls org.freedesktop.DBus.Introspectable.Introspect
@type busName: C{string}
@param busName: Name of the bus containing the object
@type objectPath: C{string}
@param objectPath: Object Path to introspect
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), the content
of the introspected XML will override any pre-existing definitions
of the contained interfaces.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to a list of L{interface.DBusInterface} instances
created from the content of the introspected XML description of the
object's interface.
"""
d = self.callRemote(
objectPath,
'Introspect',
interface='org.freedesktop.DBus.Introspectable',
destination=busName,
)
def ok(xml_str):
return introspection.getInterfacesFromXML(
xml_str,
replaceKnownInterfaces
)
def err(e):
raise error.IntrospectionFailed(
'Introspection Failed: ' + e.getErrorMessage()
)
d.addCallbacks(ok, err)
return d | [
"def",
"introspectRemoteObject",
"(",
"self",
",",
"busName",
",",
"objectPath",
",",
"replaceKnownInterfaces",
"=",
"False",
")",
":",
"d",
"=",
"self",
".",
"callRemote",
"(",
"objectPath",
",",
"'Introspect'",
",",
"interface",
"=",
"'org.freedesktop.DBus.Introspectable'",
",",
"destination",
"=",
"busName",
",",
")",
"def",
"ok",
"(",
"xml_str",
")",
":",
"return",
"introspection",
".",
"getInterfacesFromXML",
"(",
"xml_str",
",",
"replaceKnownInterfaces",
")",
"def",
"err",
"(",
"e",
")",
":",
"raise",
"error",
".",
"IntrospectionFailed",
"(",
"'Introspection Failed: '",
"+",
"e",
".",
"getErrorMessage",
"(",
")",
")",
"d",
".",
"addCallbacks",
"(",
"ok",
",",
"err",
")",
"return",
"d"
] | Calls org.freedesktop.DBus.Introspectable.Introspect
@type busName: C{string}
@param busName: Name of the bus containing the object
@type objectPath: C{string}
@param objectPath: Object Path to introspect
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If True (defaults to False), the content
of the introspected XML will override any pre-existing definitions
of the contained interfaces.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to a list of L{interface.DBusInterface} instances
created from the content of the introspected XML description of the
object's interface. | [
"Calls",
"org",
".",
"freedesktop",
".",
"DBus",
".",
"Introspectable",
".",
"Introspect"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L406-L447 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection._cbCvtReply | def _cbCvtReply(self, msg, returnSignature):
"""
Converts a remote method call reply message into an appropriate
callback
value.
"""
if msg is None:
return None
if returnSignature != _NO_CHECK_RETURN:
if not returnSignature:
if msg.signature:
raise error.RemoteError(
'Unexpected return value signature')
else:
if not msg.signature or msg.signature != returnSignature:
msg = 'Expected "%s". Received "%s"' % (
str(returnSignature), str(msg.signature))
raise error.RemoteError(
'Unexpected return value signature: %s' %
(msg,))
if msg.body is None or len(msg.body) == 0:
return None
# if not (
# isinstance(msg.body[0], six.string_types) and
# msg.body[0].startswith('<!D')
# ):
# print('RET SIG', msg.signature, 'BODY:', msg.body)
if len(msg.body) == 1 and not msg.signature[0] == '(':
return msg.body[0]
else:
return msg.body | python | def _cbCvtReply(self, msg, returnSignature):
"""
Converts a remote method call reply message into an appropriate
callback
value.
"""
if msg is None:
return None
if returnSignature != _NO_CHECK_RETURN:
if not returnSignature:
if msg.signature:
raise error.RemoteError(
'Unexpected return value signature')
else:
if not msg.signature or msg.signature != returnSignature:
msg = 'Expected "%s". Received "%s"' % (
str(returnSignature), str(msg.signature))
raise error.RemoteError(
'Unexpected return value signature: %s' %
(msg,))
if msg.body is None or len(msg.body) == 0:
return None
# if not (
# isinstance(msg.body[0], six.string_types) and
# msg.body[0].startswith('<!D')
# ):
# print('RET SIG', msg.signature, 'BODY:', msg.body)
if len(msg.body) == 1 and not msg.signature[0] == '(':
return msg.body[0]
else:
return msg.body | [
"def",
"_cbCvtReply",
"(",
"self",
",",
"msg",
",",
"returnSignature",
")",
":",
"if",
"msg",
"is",
"None",
":",
"return",
"None",
"if",
"returnSignature",
"!=",
"_NO_CHECK_RETURN",
":",
"if",
"not",
"returnSignature",
":",
"if",
"msg",
".",
"signature",
":",
"raise",
"error",
".",
"RemoteError",
"(",
"'Unexpected return value signature'",
")",
"else",
":",
"if",
"not",
"msg",
".",
"signature",
"or",
"msg",
".",
"signature",
"!=",
"returnSignature",
":",
"msg",
"=",
"'Expected \"%s\". Received \"%s\"'",
"%",
"(",
"str",
"(",
"returnSignature",
")",
",",
"str",
"(",
"msg",
".",
"signature",
")",
")",
"raise",
"error",
".",
"RemoteError",
"(",
"'Unexpected return value signature: %s'",
"%",
"(",
"msg",
",",
")",
")",
"if",
"msg",
".",
"body",
"is",
"None",
"or",
"len",
"(",
"msg",
".",
"body",
")",
"==",
"0",
":",
"return",
"None",
"# if not (",
"# isinstance(msg.body[0], six.string_types) and",
"# msg.body[0].startswith('<!D')",
"# ):",
"# print('RET SIG', msg.signature, 'BODY:', msg.body)",
"if",
"len",
"(",
"msg",
".",
"body",
")",
"==",
"1",
"and",
"not",
"msg",
".",
"signature",
"[",
"0",
"]",
"==",
"'('",
":",
"return",
"msg",
".",
"body",
"[",
"0",
"]",
"else",
":",
"return",
"msg",
".",
"body"
] | Converts a remote method call reply message into an appropriate
callback
value. | [
"Converts",
"a",
"remote",
"method",
"call",
"reply",
"message",
"into",
"an",
"appropriate",
"callback",
"value",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L449-L482 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.callRemote | def callRemote(self, objectPath, methodName,
interface=None,
destination=None,
signature=None,
body=None,
expectReply=True,
autoStart=True,
timeout=None,
returnSignature=_NO_CHECK_RETURN):
"""
Calls a method on a remote DBus object and returns a deferred to the
result.
@type objectPath: C{string}
@param objectPath: Path of the remote object
@type methodName: C{string}
@param methodName: Name of the method to call
@type interface: None or C{string}
@param interface: If specified, this specifies the interface containing
the desired method
@type destination: None or C{string}
@param destination: If specified, this specifies the bus name
containing the remote object
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus MethodCall message. This string must be a
valid Signature string as defined by the DBus specification. If
arguments are supplied to the method call, this parameter must be
provided.
@type body: C{list}
@param body: A C{list} of Python objects to encode. The list content
must match the content of the signature parameter
@type expectReply: C{bool}
@param expectReply: If True (defaults to True) the returned deferred
will be called back with the eventual result of the remote call. If
False, the deferred will be immediately called back with None.
@type autoStart: C{bool}
@param autoStart: If True (defaults to True) DBus will attempt to
automatically start a service to handle the method call if a
service matching the target object is registered but not yet
started.
@type timeout: None or C{float}
@param timeout: If specified and the remote call does not return a
value before the timeout expires, the returned Deferred will be
errbacked with a L{error.TimeOut} instance.
@type returnSignature: C{string}
@param returnSignature: If specified, the return values will be
validated against the signature string. If the returned values do
not mactch, the returned Deferred witl be errbacked with a
L{error.RemoteError} instance.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result. If expectReply is False, the
deferred will be immediately called back with None.
"""
try:
mcall = message.MethodCallMessage(
objectPath,
methodName,
interface=interface,
destination=destination,
signature=signature,
body=body,
expectReply=expectReply,
autoStart=autoStart,
oobFDs=self._toBeSentFDs,
)
d = self.callRemoteMessage(mcall, timeout)
d.addCallback(self._cbCvtReply, returnSignature)
return d
except Exception:
return defer.fail() | python | def callRemote(self, objectPath, methodName,
interface=None,
destination=None,
signature=None,
body=None,
expectReply=True,
autoStart=True,
timeout=None,
returnSignature=_NO_CHECK_RETURN):
"""
Calls a method on a remote DBus object and returns a deferred to the
result.
@type objectPath: C{string}
@param objectPath: Path of the remote object
@type methodName: C{string}
@param methodName: Name of the method to call
@type interface: None or C{string}
@param interface: If specified, this specifies the interface containing
the desired method
@type destination: None or C{string}
@param destination: If specified, this specifies the bus name
containing the remote object
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus MethodCall message. This string must be a
valid Signature string as defined by the DBus specification. If
arguments are supplied to the method call, this parameter must be
provided.
@type body: C{list}
@param body: A C{list} of Python objects to encode. The list content
must match the content of the signature parameter
@type expectReply: C{bool}
@param expectReply: If True (defaults to True) the returned deferred
will be called back with the eventual result of the remote call. If
False, the deferred will be immediately called back with None.
@type autoStart: C{bool}
@param autoStart: If True (defaults to True) DBus will attempt to
automatically start a service to handle the method call if a
service matching the target object is registered but not yet
started.
@type timeout: None or C{float}
@param timeout: If specified and the remote call does not return a
value before the timeout expires, the returned Deferred will be
errbacked with a L{error.TimeOut} instance.
@type returnSignature: C{string}
@param returnSignature: If specified, the return values will be
validated against the signature string. If the returned values do
not mactch, the returned Deferred witl be errbacked with a
L{error.RemoteError} instance.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result. If expectReply is False, the
deferred will be immediately called back with None.
"""
try:
mcall = message.MethodCallMessage(
objectPath,
methodName,
interface=interface,
destination=destination,
signature=signature,
body=body,
expectReply=expectReply,
autoStart=autoStart,
oobFDs=self._toBeSentFDs,
)
d = self.callRemoteMessage(mcall, timeout)
d.addCallback(self._cbCvtReply, returnSignature)
return d
except Exception:
return defer.fail() | [
"def",
"callRemote",
"(",
"self",
",",
"objectPath",
",",
"methodName",
",",
"interface",
"=",
"None",
",",
"destination",
"=",
"None",
",",
"signature",
"=",
"None",
",",
"body",
"=",
"None",
",",
"expectReply",
"=",
"True",
",",
"autoStart",
"=",
"True",
",",
"timeout",
"=",
"None",
",",
"returnSignature",
"=",
"_NO_CHECK_RETURN",
")",
":",
"try",
":",
"mcall",
"=",
"message",
".",
"MethodCallMessage",
"(",
"objectPath",
",",
"methodName",
",",
"interface",
"=",
"interface",
",",
"destination",
"=",
"destination",
",",
"signature",
"=",
"signature",
",",
"body",
"=",
"body",
",",
"expectReply",
"=",
"expectReply",
",",
"autoStart",
"=",
"autoStart",
",",
"oobFDs",
"=",
"self",
".",
"_toBeSentFDs",
",",
")",
"d",
"=",
"self",
".",
"callRemoteMessage",
"(",
"mcall",
",",
"timeout",
")",
"d",
".",
"addCallback",
"(",
"self",
".",
"_cbCvtReply",
",",
"returnSignature",
")",
"return",
"d",
"except",
"Exception",
":",
"return",
"defer",
".",
"fail",
"(",
")"
] | Calls a method on a remote DBus object and returns a deferred to the
result.
@type objectPath: C{string}
@param objectPath: Path of the remote object
@type methodName: C{string}
@param methodName: Name of the method to call
@type interface: None or C{string}
@param interface: If specified, this specifies the interface containing
the desired method
@type destination: None or C{string}
@param destination: If specified, this specifies the bus name
containing the remote object
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus MethodCall message. This string must be a
valid Signature string as defined by the DBus specification. If
arguments are supplied to the method call, this parameter must be
provided.
@type body: C{list}
@param body: A C{list} of Python objects to encode. The list content
must match the content of the signature parameter
@type expectReply: C{bool}
@param expectReply: If True (defaults to True) the returned deferred
will be called back with the eventual result of the remote call. If
False, the deferred will be immediately called back with None.
@type autoStart: C{bool}
@param autoStart: If True (defaults to True) DBus will attempt to
automatically start a service to handle the method call if a
service matching the target object is registered but not yet
started.
@type timeout: None or C{float}
@param timeout: If specified and the remote call does not return a
value before the timeout expires, the returned Deferred will be
errbacked with a L{error.TimeOut} instance.
@type returnSignature: C{string}
@param returnSignature: If specified, the return values will be
validated against the signature string. If the returned values do
not mactch, the returned Deferred witl be errbacked with a
L{error.RemoteError} instance.
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result. If expectReply is False, the
deferred will be immediately called back with None. | [
"Calls",
"a",
"method",
"on",
"a",
"remote",
"DBus",
"object",
"and",
"returns",
"a",
"deferred",
"to",
"the",
"result",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L484-L568 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection._onMethodTimeout | def _onMethodTimeout(self, serial, d):
"""
Called when a remote method invocation timeout occurs
"""
del self._pendingCalls[serial]
d.errback(error.TimeOut('Method call timed out')) | python | def _onMethodTimeout(self, serial, d):
"""
Called when a remote method invocation timeout occurs
"""
del self._pendingCalls[serial]
d.errback(error.TimeOut('Method call timed out')) | [
"def",
"_onMethodTimeout",
"(",
"self",
",",
"serial",
",",
"d",
")",
":",
"del",
"self",
".",
"_pendingCalls",
"[",
"serial",
"]",
"d",
".",
"errback",
"(",
"error",
".",
"TimeOut",
"(",
"'Method call timed out'",
")",
")"
] | Called when a remote method invocation timeout occurs | [
"Called",
"when",
"a",
"remote",
"method",
"invocation",
"timeout",
"occurs"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L570-L575 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.callRemoteMessage | def callRemoteMessage(self, mcall, timeout=None):
"""
Uses the specified L{message.MethodCallMessage} to call a remote method
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote method call
"""
assert isinstance(mcall, message.MethodCallMessage)
if mcall.expectReply:
d = defer.Deferred()
if timeout:
timeout = reactor.callLater(
timeout, self._onMethodTimeout, mcall.serial, d)
self._pendingCalls[mcall.serial] = (d, timeout)
self.sendMessage(mcall)
return d
else:
self.sendMessage(mcall)
return defer.succeed(None) | python | def callRemoteMessage(self, mcall, timeout=None):
"""
Uses the specified L{message.MethodCallMessage} to call a remote method
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote method call
"""
assert isinstance(mcall, message.MethodCallMessage)
if mcall.expectReply:
d = defer.Deferred()
if timeout:
timeout = reactor.callLater(
timeout, self._onMethodTimeout, mcall.serial, d)
self._pendingCalls[mcall.serial] = (d, timeout)
self.sendMessage(mcall)
return d
else:
self.sendMessage(mcall)
return defer.succeed(None) | [
"def",
"callRemoteMessage",
"(",
"self",
",",
"mcall",
",",
"timeout",
"=",
"None",
")",
":",
"assert",
"isinstance",
"(",
"mcall",
",",
"message",
".",
"MethodCallMessage",
")",
"if",
"mcall",
".",
"expectReply",
":",
"d",
"=",
"defer",
".",
"Deferred",
"(",
")",
"if",
"timeout",
":",
"timeout",
"=",
"reactor",
".",
"callLater",
"(",
"timeout",
",",
"self",
".",
"_onMethodTimeout",
",",
"mcall",
".",
"serial",
",",
"d",
")",
"self",
".",
"_pendingCalls",
"[",
"mcall",
".",
"serial",
"]",
"=",
"(",
"d",
",",
"timeout",
")",
"self",
".",
"sendMessage",
"(",
"mcall",
")",
"return",
"d",
"else",
":",
"self",
".",
"sendMessage",
"(",
"mcall",
")",
"return",
"defer",
".",
"succeed",
"(",
"None",
")"
] | Uses the specified L{message.MethodCallMessage} to call a remote method
@rtype: L{twisted.internet.defer.Deferred}
@returns: a Deferred to the result of the remote method call | [
"Uses",
"the",
"specified",
"L",
"{",
"message",
".",
"MethodCallMessage",
"}",
"to",
"call",
"a",
"remote",
"method"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L577-L601 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.methodReturnReceived | def methodReturnReceived(self, mret):
"""
Called when a method return message is received
"""
d, timeout = self._pendingCalls.get(mret.reply_serial, (None, None))
if timeout:
timeout.cancel()
if d:
del self._pendingCalls[mret.reply_serial]
d.callback(mret) | python | def methodReturnReceived(self, mret):
"""
Called when a method return message is received
"""
d, timeout = self._pendingCalls.get(mret.reply_serial, (None, None))
if timeout:
timeout.cancel()
if d:
del self._pendingCalls[mret.reply_serial]
d.callback(mret) | [
"def",
"methodReturnReceived",
"(",
"self",
",",
"mret",
")",
":",
"d",
",",
"timeout",
"=",
"self",
".",
"_pendingCalls",
".",
"get",
"(",
"mret",
".",
"reply_serial",
",",
"(",
"None",
",",
"None",
")",
")",
"if",
"timeout",
":",
"timeout",
".",
"cancel",
"(",
")",
"if",
"d",
":",
"del",
"self",
".",
"_pendingCalls",
"[",
"mret",
".",
"reply_serial",
"]",
"d",
".",
"callback",
"(",
"mret",
")"
] | Called when a method return message is received | [
"Called",
"when",
"a",
"method",
"return",
"message",
"is",
"received"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L609-L618 |
cocagne/txdbus | txdbus/client.py | DBusClientConnection.errorReceived | def errorReceived(self, merr):
"""
Called when an error message is received
"""
d, timeout = self._pendingCalls.get(merr.reply_serial, (None, None))
if timeout:
timeout.cancel()
if d:
del self._pendingCalls[merr.reply_serial]
e = error.RemoteError(merr.error_name)
e.message = ''
e.values = []
if merr.body:
if isinstance(merr.body[0], six.string_types):
e.message = merr.body[0]
e.values = merr.body
d.errback(e) | python | def errorReceived(self, merr):
"""
Called when an error message is received
"""
d, timeout = self._pendingCalls.get(merr.reply_serial, (None, None))
if timeout:
timeout.cancel()
if d:
del self._pendingCalls[merr.reply_serial]
e = error.RemoteError(merr.error_name)
e.message = ''
e.values = []
if merr.body:
if isinstance(merr.body[0], six.string_types):
e.message = merr.body[0]
e.values = merr.body
d.errback(e) | [
"def",
"errorReceived",
"(",
"self",
",",
"merr",
")",
":",
"d",
",",
"timeout",
"=",
"self",
".",
"_pendingCalls",
".",
"get",
"(",
"merr",
".",
"reply_serial",
",",
"(",
"None",
",",
"None",
")",
")",
"if",
"timeout",
":",
"timeout",
".",
"cancel",
"(",
")",
"if",
"d",
":",
"del",
"self",
".",
"_pendingCalls",
"[",
"merr",
".",
"reply_serial",
"]",
"e",
"=",
"error",
".",
"RemoteError",
"(",
"merr",
".",
"error_name",
")",
"e",
".",
"message",
"=",
"''",
"e",
".",
"values",
"=",
"[",
"]",
"if",
"merr",
".",
"body",
":",
"if",
"isinstance",
"(",
"merr",
".",
"body",
"[",
"0",
"]",
",",
"six",
".",
"string_types",
")",
":",
"e",
".",
"message",
"=",
"merr",
".",
"body",
"[",
"0",
"]",
"e",
".",
"values",
"=",
"merr",
".",
"body",
"d",
".",
"errback",
"(",
"e",
")"
] | Called when an error message is received | [
"Called",
"when",
"an",
"error",
"message",
"is",
"received"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/client.py#L620-L636 |
cocagne/txdbus | txdbus/endpoints.py | getDBusEnvEndpoints | def getDBusEnvEndpoints(reactor, client=True):
"""
Creates endpoints from the DBUS_SESSION_BUS_ADDRESS environment variable
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances
"""
env = os.environ.get('DBUS_SESSION_BUS_ADDRESS', None)
if env is None:
raise Exception('DBus Session environment variable not set')
return getDBusEndpoints(reactor, env, client) | python | def getDBusEnvEndpoints(reactor, client=True):
"""
Creates endpoints from the DBUS_SESSION_BUS_ADDRESS environment variable
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances
"""
env = os.environ.get('DBUS_SESSION_BUS_ADDRESS', None)
if env is None:
raise Exception('DBus Session environment variable not set')
return getDBusEndpoints(reactor, env, client) | [
"def",
"getDBusEnvEndpoints",
"(",
"reactor",
",",
"client",
"=",
"True",
")",
":",
"env",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'DBUS_SESSION_BUS_ADDRESS'",
",",
"None",
")",
"if",
"env",
"is",
"None",
":",
"raise",
"Exception",
"(",
"'DBus Session environment variable not set'",
")",
"return",
"getDBusEndpoints",
"(",
"reactor",
",",
"env",
",",
"client",
")"
] | Creates endpoints from the DBUS_SESSION_BUS_ADDRESS environment variable
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances | [
"Creates",
"endpoints",
"from",
"the",
"DBUS_SESSION_BUS_ADDRESS",
"environment",
"variable"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/endpoints.py#L16-L27 |
cocagne/txdbus | txdbus/endpoints.py | getDBusEndpoints | def getDBusEndpoints(reactor, busAddress, client=True):
"""
Creates DBus endpoints.
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances
"""
if busAddress == 'session':
addrString = os.environ.get('DBUS_SESSION_BUS_ADDRESS', None)
if addrString is None:
raise Exception('DBus Session environment variable not set')
elif busAddress == 'system':
addrString = os.environ.get(
'DBUS_SYSTEM_BUS_ADDRESS',
'unix:path=/var/run/dbus/system_bus_socket',
)
else:
addrString = busAddress
# XXX Add documentation about extra key=value parameters in address string
# such as nonce-tcp vs tcp which use same endpoint class
epl = []
for ep_addr in addrString.split(';'):
d = {}
kind = None
ep = None
for c in ep_addr.split(','):
if c.startswith('unix:'):
kind = 'unix'
c = c[5:]
elif c.startswith('tcp:'):
kind = 'tcp'
c = c[4:]
elif c.startswith('nonce-tcp:'):
kind = 'tcp'
c = c[10:]
d['nonce-tcp'] = True
elif c.startswith('launchd:'):
kind = 'launchd'
c = c[7:]
if '=' in c:
k, v = c.split('=')
d[k] = v
if kind == 'unix':
if 'path' in d:
path = d['path']
elif 'tmpdir' in d:
path = d['tmpdir'] + '/dbus-' + str(os.getpid())
elif 'abstract' in d:
path = '\0' + d['abstract']
if client:
ep = UNIXClientEndpoint(reactor, path=path)
else:
ep = UNIXServerEndpoint(reactor, address=path)
elif kind == 'tcp':
if client:
ep = TCP4ClientEndpoint(reactor, d['host'], int(d['port']))
else:
ep = TCP4ServerEndpoint(reactor, int(
d['port']), interface=d['host'])
if ep:
ep.dbus_args = d
epl.append(ep)
return epl | python | def getDBusEndpoints(reactor, busAddress, client=True):
"""
Creates DBus endpoints.
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances
"""
if busAddress == 'session':
addrString = os.environ.get('DBUS_SESSION_BUS_ADDRESS', None)
if addrString is None:
raise Exception('DBus Session environment variable not set')
elif busAddress == 'system':
addrString = os.environ.get(
'DBUS_SYSTEM_BUS_ADDRESS',
'unix:path=/var/run/dbus/system_bus_socket',
)
else:
addrString = busAddress
# XXX Add documentation about extra key=value parameters in address string
# such as nonce-tcp vs tcp which use same endpoint class
epl = []
for ep_addr in addrString.split(';'):
d = {}
kind = None
ep = None
for c in ep_addr.split(','):
if c.startswith('unix:'):
kind = 'unix'
c = c[5:]
elif c.startswith('tcp:'):
kind = 'tcp'
c = c[4:]
elif c.startswith('nonce-tcp:'):
kind = 'tcp'
c = c[10:]
d['nonce-tcp'] = True
elif c.startswith('launchd:'):
kind = 'launchd'
c = c[7:]
if '=' in c:
k, v = c.split('=')
d[k] = v
if kind == 'unix':
if 'path' in d:
path = d['path']
elif 'tmpdir' in d:
path = d['tmpdir'] + '/dbus-' + str(os.getpid())
elif 'abstract' in d:
path = '\0' + d['abstract']
if client:
ep = UNIXClientEndpoint(reactor, path=path)
else:
ep = UNIXServerEndpoint(reactor, address=path)
elif kind == 'tcp':
if client:
ep = TCP4ClientEndpoint(reactor, d['host'], int(d['port']))
else:
ep = TCP4ServerEndpoint(reactor, int(
d['port']), interface=d['host'])
if ep:
ep.dbus_args = d
epl.append(ep)
return epl | [
"def",
"getDBusEndpoints",
"(",
"reactor",
",",
"busAddress",
",",
"client",
"=",
"True",
")",
":",
"if",
"busAddress",
"==",
"'session'",
":",
"addrString",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'DBUS_SESSION_BUS_ADDRESS'",
",",
"None",
")",
"if",
"addrString",
"is",
"None",
":",
"raise",
"Exception",
"(",
"'DBus Session environment variable not set'",
")",
"elif",
"busAddress",
"==",
"'system'",
":",
"addrString",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'DBUS_SYSTEM_BUS_ADDRESS'",
",",
"'unix:path=/var/run/dbus/system_bus_socket'",
",",
")",
"else",
":",
"addrString",
"=",
"busAddress",
"# XXX Add documentation about extra key=value parameters in address string",
"# such as nonce-tcp vs tcp which use same endpoint class",
"epl",
"=",
"[",
"]",
"for",
"ep_addr",
"in",
"addrString",
".",
"split",
"(",
"';'",
")",
":",
"d",
"=",
"{",
"}",
"kind",
"=",
"None",
"ep",
"=",
"None",
"for",
"c",
"in",
"ep_addr",
".",
"split",
"(",
"','",
")",
":",
"if",
"c",
".",
"startswith",
"(",
"'unix:'",
")",
":",
"kind",
"=",
"'unix'",
"c",
"=",
"c",
"[",
"5",
":",
"]",
"elif",
"c",
".",
"startswith",
"(",
"'tcp:'",
")",
":",
"kind",
"=",
"'tcp'",
"c",
"=",
"c",
"[",
"4",
":",
"]",
"elif",
"c",
".",
"startswith",
"(",
"'nonce-tcp:'",
")",
":",
"kind",
"=",
"'tcp'",
"c",
"=",
"c",
"[",
"10",
":",
"]",
"d",
"[",
"'nonce-tcp'",
"]",
"=",
"True",
"elif",
"c",
".",
"startswith",
"(",
"'launchd:'",
")",
":",
"kind",
"=",
"'launchd'",
"c",
"=",
"c",
"[",
"7",
":",
"]",
"if",
"'='",
"in",
"c",
":",
"k",
",",
"v",
"=",
"c",
".",
"split",
"(",
"'='",
")",
"d",
"[",
"k",
"]",
"=",
"v",
"if",
"kind",
"==",
"'unix'",
":",
"if",
"'path'",
"in",
"d",
":",
"path",
"=",
"d",
"[",
"'path'",
"]",
"elif",
"'tmpdir'",
"in",
"d",
":",
"path",
"=",
"d",
"[",
"'tmpdir'",
"]",
"+",
"'/dbus-'",
"+",
"str",
"(",
"os",
".",
"getpid",
"(",
")",
")",
"elif",
"'abstract'",
"in",
"d",
":",
"path",
"=",
"'\\0'",
"+",
"d",
"[",
"'abstract'",
"]",
"if",
"client",
":",
"ep",
"=",
"UNIXClientEndpoint",
"(",
"reactor",
",",
"path",
"=",
"path",
")",
"else",
":",
"ep",
"=",
"UNIXServerEndpoint",
"(",
"reactor",
",",
"address",
"=",
"path",
")",
"elif",
"kind",
"==",
"'tcp'",
":",
"if",
"client",
":",
"ep",
"=",
"TCP4ClientEndpoint",
"(",
"reactor",
",",
"d",
"[",
"'host'",
"]",
",",
"int",
"(",
"d",
"[",
"'port'",
"]",
")",
")",
"else",
":",
"ep",
"=",
"TCP4ServerEndpoint",
"(",
"reactor",
",",
"int",
"(",
"d",
"[",
"'port'",
"]",
")",
",",
"interface",
"=",
"d",
"[",
"'host'",
"]",
")",
"if",
"ep",
":",
"ep",
".",
"dbus_args",
"=",
"d",
"epl",
".",
"append",
"(",
"ep",
")",
"return",
"epl"
] | Creates DBus endpoints.
@param busAddress: 'session', 'system', or a valid bus address as defined
by the DBus specification. If 'session' (the default) or 'system' is
supplied, the contents of the DBUS_SESSION_BUS_ADDRESS or
DBUS_SYSTEM_BUS_ADDRESS environment variables will be used for the bus
address, respectively. If DBUS_SYSTEM_BUS_ADDRESS is not set, the
well-known address unix:path=/var/run/dbus/system_bus_socket will be
used.
@type busAddress: C{string}
@rtype: C{list} of L{twisted.internet.interfaces.IStreamServerEndpoint}
@returns: A list of endpoint instances | [
"Creates",
"DBus",
"endpoints",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/endpoints.py#L30-L113 |
cocagne/txdbus | txdbus/marshal.py | validateObjectPath | def validateObjectPath(p):
"""
Ensures that the provided object path conforms to the DBus standard.
Throws a L{error.MarshallingError} if non-conformant
@type p: C{string}
@param p: A DBus object path
"""
if not p.startswith('/'):
raise MarshallingError('Object paths must begin with a "/"')
if len(p) > 1 and p[-1] == '/':
raise MarshallingError('Object paths may not end with "/"')
if '//' in p:
raise MarshallingError('"//" is not allowed in object paths"')
if invalid_obj_path_re.search(p):
raise MarshallingError('Invalid characters contained in object path') | python | def validateObjectPath(p):
"""
Ensures that the provided object path conforms to the DBus standard.
Throws a L{error.MarshallingError} if non-conformant
@type p: C{string}
@param p: A DBus object path
"""
if not p.startswith('/'):
raise MarshallingError('Object paths must begin with a "/"')
if len(p) > 1 and p[-1] == '/':
raise MarshallingError('Object paths may not end with "/"')
if '//' in p:
raise MarshallingError('"//" is not allowed in object paths"')
if invalid_obj_path_re.search(p):
raise MarshallingError('Invalid characters contained in object path') | [
"def",
"validateObjectPath",
"(",
"p",
")",
":",
"if",
"not",
"p",
".",
"startswith",
"(",
"'/'",
")",
":",
"raise",
"MarshallingError",
"(",
"'Object paths must begin with a \"/\"'",
")",
"if",
"len",
"(",
"p",
")",
">",
"1",
"and",
"p",
"[",
"-",
"1",
"]",
"==",
"'/'",
":",
"raise",
"MarshallingError",
"(",
"'Object paths may not end with \"/\"'",
")",
"if",
"'//'",
"in",
"p",
":",
"raise",
"MarshallingError",
"(",
"'\"//\" is not allowed in object paths\"'",
")",
"if",
"invalid_obj_path_re",
".",
"search",
"(",
"p",
")",
":",
"raise",
"MarshallingError",
"(",
"'Invalid characters contained in object path'",
")"
] | Ensures that the provided object path conforms to the DBus standard.
Throws a L{error.MarshallingError} if non-conformant
@type p: C{string}
@param p: A DBus object path | [
"Ensures",
"that",
"the",
"provided",
"object",
"path",
"conforms",
"to",
"the",
"DBus",
"standard",
".",
"Throws",
"a",
"L",
"{",
"error",
".",
"MarshallingError",
"}",
"if",
"non",
"-",
"conformant"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/marshal.py#L138-L153 |
cocagne/txdbus | txdbus/marshal.py | validateInterfaceName | def validateInterfaceName(n):
"""
Verifies that the supplied name is a valid DBus Interface name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus interface name
"""
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in interface names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0] == '.':
raise Exception('Names may not begin with a "."')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if if_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_.]')
if dot_digit_re.search(n):
raise Exception(
'No components of an interface name may begin with a digit')
except Exception as e:
raise MarshallingError('Invalid interface name "%s": %s' % (n, str(e))) | python | def validateInterfaceName(n):
"""
Verifies that the supplied name is a valid DBus Interface name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus interface name
"""
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in interface names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0] == '.':
raise Exception('Names may not begin with a "."')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if if_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_.]')
if dot_digit_re.search(n):
raise Exception(
'No components of an interface name may begin with a digit')
except Exception as e:
raise MarshallingError('Invalid interface name "%s": %s' % (n, str(e))) | [
"def",
"validateInterfaceName",
"(",
"n",
")",
":",
"try",
":",
"if",
"'.'",
"not",
"in",
"n",
":",
"raise",
"Exception",
"(",
"'At least two components required'",
")",
"if",
"'..'",
"in",
"n",
":",
"raise",
"Exception",
"(",
"'\"..\" not allowed in interface names'",
")",
"if",
"len",
"(",
"n",
")",
">",
"255",
":",
"raise",
"Exception",
"(",
"'Name exceeds maximum length of 255'",
")",
"if",
"n",
"[",
"0",
"]",
"==",
"'.'",
":",
"raise",
"Exception",
"(",
"'Names may not begin with a \".\"'",
")",
"if",
"n",
"[",
"0",
"]",
".",
"isdigit",
"(",
")",
":",
"raise",
"Exception",
"(",
"'Names may not begin with a digit'",
")",
"if",
"if_re",
".",
"search",
"(",
"n",
")",
":",
"raise",
"Exception",
"(",
"'Names contains a character outside the set [A-Za-z0-9_.]'",
")",
"if",
"dot_digit_re",
".",
"search",
"(",
"n",
")",
":",
"raise",
"Exception",
"(",
"'No components of an interface name may begin with a digit'",
")",
"except",
"Exception",
"as",
"e",
":",
"raise",
"MarshallingError",
"(",
"'Invalid interface name \"%s\": %s'",
"%",
"(",
"n",
",",
"str",
"(",
"e",
")",
")",
")"
] | Verifies that the supplied name is a valid DBus Interface name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus interface name | [
"Verifies",
"that",
"the",
"supplied",
"name",
"is",
"a",
"valid",
"DBus",
"Interface",
"name",
".",
"Throws",
"an",
"L",
"{",
"error",
".",
"MarshallingError",
"}",
"if",
"the",
"format",
"is",
"invalid"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/marshal.py#L156-L182 |
cocagne/txdbus | txdbus/marshal.py | validateBusName | def validateBusName(n):
"""
Verifies that the supplied name is a valid DBus Bus name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus bus name
"""
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in bus names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0] == '.':
raise Exception('Names may not begin with a "."')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if bus_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_.\\-:]')
if not n[0] == ':' and dot_digit_re.search(n):
raise Exception(
'No coponents of an interface name may begin with a digit')
except Exception as e:
raise MarshallingError('Invalid bus name "%s": %s' % (n, str(e))) | python | def validateBusName(n):
"""
Verifies that the supplied name is a valid DBus Bus name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus bus name
"""
try:
if '.' not in n:
raise Exception('At least two components required')
if '..' in n:
raise Exception('".." not allowed in bus names')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0] == '.':
raise Exception('Names may not begin with a "."')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if bus_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_.\\-:]')
if not n[0] == ':' and dot_digit_re.search(n):
raise Exception(
'No coponents of an interface name may begin with a digit')
except Exception as e:
raise MarshallingError('Invalid bus name "%s": %s' % (n, str(e))) | [
"def",
"validateBusName",
"(",
"n",
")",
":",
"try",
":",
"if",
"'.'",
"not",
"in",
"n",
":",
"raise",
"Exception",
"(",
"'At least two components required'",
")",
"if",
"'..'",
"in",
"n",
":",
"raise",
"Exception",
"(",
"'\"..\" not allowed in bus names'",
")",
"if",
"len",
"(",
"n",
")",
">",
"255",
":",
"raise",
"Exception",
"(",
"'Name exceeds maximum length of 255'",
")",
"if",
"n",
"[",
"0",
"]",
"==",
"'.'",
":",
"raise",
"Exception",
"(",
"'Names may not begin with a \".\"'",
")",
"if",
"n",
"[",
"0",
"]",
".",
"isdigit",
"(",
")",
":",
"raise",
"Exception",
"(",
"'Names may not begin with a digit'",
")",
"if",
"bus_re",
".",
"search",
"(",
"n",
")",
":",
"raise",
"Exception",
"(",
"'Names contains a character outside the set [A-Za-z0-9_.\\\\-:]'",
")",
"if",
"not",
"n",
"[",
"0",
"]",
"==",
"':'",
"and",
"dot_digit_re",
".",
"search",
"(",
"n",
")",
":",
"raise",
"Exception",
"(",
"'No coponents of an interface name may begin with a digit'",
")",
"except",
"Exception",
"as",
"e",
":",
"raise",
"MarshallingError",
"(",
"'Invalid bus name \"%s\": %s'",
"%",
"(",
"n",
",",
"str",
"(",
"e",
")",
")",
")"
] | Verifies that the supplied name is a valid DBus Bus name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus bus name | [
"Verifies",
"that",
"the",
"supplied",
"name",
"is",
"a",
"valid",
"DBus",
"Bus",
"name",
".",
"Throws",
"an",
"L",
"{",
"error",
".",
"MarshallingError",
"}",
"if",
"the",
"format",
"is",
"invalid"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/marshal.py#L192-L218 |
cocagne/txdbus | txdbus/marshal.py | validateMemberName | def validateMemberName(n):
"""
Verifies that the supplied name is a valid DBus member name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus member name
"""
try:
if len(n) < 1:
raise Exception('Name must be at least one byte in length')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if mbr_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_]')
except Exception as e:
raise MarshallingError('Invalid member name "%s": %s' % (n, str(e))) | python | def validateMemberName(n):
"""
Verifies that the supplied name is a valid DBus member name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus member name
"""
try:
if len(n) < 1:
raise Exception('Name must be at least one byte in length')
if len(n) > 255:
raise Exception('Name exceeds maximum length of 255')
if n[0].isdigit():
raise Exception('Names may not begin with a digit')
if mbr_re.search(n):
raise Exception(
'Names contains a character outside the set [A-Za-z0-9_]')
except Exception as e:
raise MarshallingError('Invalid member name "%s": %s' % (n, str(e))) | [
"def",
"validateMemberName",
"(",
"n",
")",
":",
"try",
":",
"if",
"len",
"(",
"n",
")",
"<",
"1",
":",
"raise",
"Exception",
"(",
"'Name must be at least one byte in length'",
")",
"if",
"len",
"(",
"n",
")",
">",
"255",
":",
"raise",
"Exception",
"(",
"'Name exceeds maximum length of 255'",
")",
"if",
"n",
"[",
"0",
"]",
".",
"isdigit",
"(",
")",
":",
"raise",
"Exception",
"(",
"'Names may not begin with a digit'",
")",
"if",
"mbr_re",
".",
"search",
"(",
"n",
")",
":",
"raise",
"Exception",
"(",
"'Names contains a character outside the set [A-Za-z0-9_]'",
")",
"except",
"Exception",
"as",
"e",
":",
"raise",
"MarshallingError",
"(",
"'Invalid member name \"%s\": %s'",
"%",
"(",
"n",
",",
"str",
"(",
"e",
")",
")",
")"
] | Verifies that the supplied name is a valid DBus member name. Throws
an L{error.MarshallingError} if the format is invalid
@type n: C{string}
@param n: A DBus member name | [
"Verifies",
"that",
"the",
"supplied",
"name",
"is",
"a",
"valid",
"DBus",
"member",
"name",
".",
"Throws",
"an",
"L",
"{",
"error",
".",
"MarshallingError",
"}",
"if",
"the",
"format",
"is",
"invalid"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/marshal.py#L221-L240 |
cocagne/txdbus | doc/examples/fd_server.py | FDObject.dbus_lenFD | def dbus_lenFD(self, fd):
"""
Returns the byte count after reading till EOF.
"""
f = os.fdopen(fd, 'rb')
result = len(f.read())
f.close()
return result | python | def dbus_lenFD(self, fd):
"""
Returns the byte count after reading till EOF.
"""
f = os.fdopen(fd, 'rb')
result = len(f.read())
f.close()
return result | [
"def",
"dbus_lenFD",
"(",
"self",
",",
"fd",
")",
":",
"f",
"=",
"os",
".",
"fdopen",
"(",
"fd",
",",
"'rb'",
")",
"result",
"=",
"len",
"(",
"f",
".",
"read",
"(",
")",
")",
"f",
".",
"close",
"(",
")",
"return",
"result"
] | Returns the byte count after reading till EOF. | [
"Returns",
"the",
"byte",
"count",
"after",
"reading",
"till",
"EOF",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/doc/examples/fd_server.py#L46-L53 |
cocagne/txdbus | doc/examples/fd_server.py | FDObject.dbus_readBytesFD | def dbus_readBytesFD(self, fd, byte_count):
"""
Reads byte_count bytes from fd and returns them.
"""
f = os.fdopen(fd, 'rb')
result = f.read(byte_count)
f.close()
return bytearray(result) | python | def dbus_readBytesFD(self, fd, byte_count):
"""
Reads byte_count bytes from fd and returns them.
"""
f = os.fdopen(fd, 'rb')
result = f.read(byte_count)
f.close()
return bytearray(result) | [
"def",
"dbus_readBytesFD",
"(",
"self",
",",
"fd",
",",
"byte_count",
")",
":",
"f",
"=",
"os",
".",
"fdopen",
"(",
"fd",
",",
"'rb'",
")",
"result",
"=",
"f",
".",
"read",
"(",
"byte_count",
")",
"f",
".",
"close",
"(",
")",
"return",
"bytearray",
"(",
"result",
")"
] | Reads byte_count bytes from fd and returns them. | [
"Reads",
"byte_count",
"bytes",
"from",
"fd",
"and",
"returns",
"them",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/doc/examples/fd_server.py#L56-L63 |
cocagne/txdbus | doc/examples/fd_server.py | FDObject.dbus_readBytesTwoFDs | def dbus_readBytesTwoFDs(self, fd1, fd2, byte_count):
"""
Reads byte_count from fd1 and fd2. Returns concatenation.
"""
result = bytearray()
for fd in (fd1, fd2):
f = os.fdopen(fd, 'rb')
result.extend(f.read(byte_count))
f.close()
return result | python | def dbus_readBytesTwoFDs(self, fd1, fd2, byte_count):
"""
Reads byte_count from fd1 and fd2. Returns concatenation.
"""
result = bytearray()
for fd in (fd1, fd2):
f = os.fdopen(fd, 'rb')
result.extend(f.read(byte_count))
f.close()
return result | [
"def",
"dbus_readBytesTwoFDs",
"(",
"self",
",",
"fd1",
",",
"fd2",
",",
"byte_count",
")",
":",
"result",
"=",
"bytearray",
"(",
")",
"for",
"fd",
"in",
"(",
"fd1",
",",
"fd2",
")",
":",
"f",
"=",
"os",
".",
"fdopen",
"(",
"fd",
",",
"'rb'",
")",
"result",
".",
"extend",
"(",
"f",
".",
"read",
"(",
"byte_count",
")",
")",
"f",
".",
"close",
"(",
")",
"return",
"result"
] | Reads byte_count from fd1 and fd2. Returns concatenation. | [
"Reads",
"byte_count",
"from",
"fd1",
"and",
"fd2",
".",
"Returns",
"concatenation",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/doc/examples/fd_server.py#L66-L75 |
cocagne/txdbus | txdbus/introspection.py | generateIntrospectionXML | def generateIntrospectionXML(objectPath, exportedObjects):
"""
Generates the introspection XML for an object path or partial object path
that matches exported objects.
This allows for browsing the exported objects with tools such as d-feet.
@rtype: C{string}
"""
l = [_dtd_decl]
l.append('<node name="%s">' % (objectPath,))
obj = exportedObjects.get(objectPath, None)
if obj is not None:
for i in obj.getInterfaces():
l.append(i.introspectionXml)
l.append(_intro)
# make sure objectPath ends with '/' to only get partial matches based on
# the full path, not a part of a subpath
if not objectPath.endswith('/'):
objectPath += '/'
matches = []
for path in exportedObjects.keys():
if path.startswith(objectPath):
path = path[len(objectPath):].partition('/')[0]
if path not in matches:
matches.append(path)
if obj is None and not matches:
return None
for m in matches:
l.append('<node name="%s"/>' % m)
l.append('</node>')
return '\n'.join(l) | python | def generateIntrospectionXML(objectPath, exportedObjects):
"""
Generates the introspection XML for an object path or partial object path
that matches exported objects.
This allows for browsing the exported objects with tools such as d-feet.
@rtype: C{string}
"""
l = [_dtd_decl]
l.append('<node name="%s">' % (objectPath,))
obj = exportedObjects.get(objectPath, None)
if obj is not None:
for i in obj.getInterfaces():
l.append(i.introspectionXml)
l.append(_intro)
# make sure objectPath ends with '/' to only get partial matches based on
# the full path, not a part of a subpath
if not objectPath.endswith('/'):
objectPath += '/'
matches = []
for path in exportedObjects.keys():
if path.startswith(objectPath):
path = path[len(objectPath):].partition('/')[0]
if path not in matches:
matches.append(path)
if obj is None and not matches:
return None
for m in matches:
l.append('<node name="%s"/>' % m)
l.append('</node>')
return '\n'.join(l) | [
"def",
"generateIntrospectionXML",
"(",
"objectPath",
",",
"exportedObjects",
")",
":",
"l",
"=",
"[",
"_dtd_decl",
"]",
"l",
".",
"append",
"(",
"'<node name=\"%s\">'",
"%",
"(",
"objectPath",
",",
")",
")",
"obj",
"=",
"exportedObjects",
".",
"get",
"(",
"objectPath",
",",
"None",
")",
"if",
"obj",
"is",
"not",
"None",
":",
"for",
"i",
"in",
"obj",
".",
"getInterfaces",
"(",
")",
":",
"l",
".",
"append",
"(",
"i",
".",
"introspectionXml",
")",
"l",
".",
"append",
"(",
"_intro",
")",
"# make sure objectPath ends with '/' to only get partial matches based on",
"# the full path, not a part of a subpath",
"if",
"not",
"objectPath",
".",
"endswith",
"(",
"'/'",
")",
":",
"objectPath",
"+=",
"'/'",
"matches",
"=",
"[",
"]",
"for",
"path",
"in",
"exportedObjects",
".",
"keys",
"(",
")",
":",
"if",
"path",
".",
"startswith",
"(",
"objectPath",
")",
":",
"path",
"=",
"path",
"[",
"len",
"(",
"objectPath",
")",
":",
"]",
".",
"partition",
"(",
"'/'",
")",
"[",
"0",
"]",
"if",
"path",
"not",
"in",
"matches",
":",
"matches",
".",
"append",
"(",
"path",
")",
"if",
"obj",
"is",
"None",
"and",
"not",
"matches",
":",
"return",
"None",
"for",
"m",
"in",
"matches",
":",
"l",
".",
"append",
"(",
"'<node name=\"%s\"/>'",
"%",
"m",
")",
"l",
".",
"append",
"(",
"'</node>'",
")",
"return",
"'\\n'",
".",
"join",
"(",
"l",
")"
] | Generates the introspection XML for an object path or partial object path
that matches exported objects.
This allows for browsing the exported objects with tools such as d-feet.
@rtype: C{string} | [
"Generates",
"the",
"introspection",
"XML",
"for",
"an",
"object",
"path",
"or",
"partial",
"object",
"path",
"that",
"matches",
"exported",
"objects",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/introspection.py#L34-L70 |
cocagne/txdbus | txdbus/introspection.py | getInterfacesFromXML | def getInterfacesFromXML(xmlStr, replaceKnownInterfaces=False):
"""
Parses the supplied Introspection XML string and returns a list of
L{interface.DBusInerface} instances representing the XML interface
definitions.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If true, pre-existing interface definitions
will be replaced by the contents of the
interfaces defined within the XML string
@rtype: C{list} of L{interface.DBusInerface}
"""
handler = IntrospectionHandler(replaceKnownInterfaces)
xmlStr = xmlStr.strip()
if xmlStr.startswith('<!DOCTYPE'):
xmlStr = xmlStr[xmlStr.find('>') + 1:]
# xml.sax.parseString( xmlStr, handler )
p = xml.sax.make_parser()
p.setFeature(xml.sax.handler.feature_validation, False)
p.setFeature(xml.sax.handler.feature_external_ges, False)
p.setContentHandler(handler)
p.parse(cStringIO(xmlStr))
return handler.interfaces | python | def getInterfacesFromXML(xmlStr, replaceKnownInterfaces=False):
"""
Parses the supplied Introspection XML string and returns a list of
L{interface.DBusInerface} instances representing the XML interface
definitions.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If true, pre-existing interface definitions
will be replaced by the contents of the
interfaces defined within the XML string
@rtype: C{list} of L{interface.DBusInerface}
"""
handler = IntrospectionHandler(replaceKnownInterfaces)
xmlStr = xmlStr.strip()
if xmlStr.startswith('<!DOCTYPE'):
xmlStr = xmlStr[xmlStr.find('>') + 1:]
# xml.sax.parseString( xmlStr, handler )
p = xml.sax.make_parser()
p.setFeature(xml.sax.handler.feature_validation, False)
p.setFeature(xml.sax.handler.feature_external_ges, False)
p.setContentHandler(handler)
p.parse(cStringIO(xmlStr))
return handler.interfaces | [
"def",
"getInterfacesFromXML",
"(",
"xmlStr",
",",
"replaceKnownInterfaces",
"=",
"False",
")",
":",
"handler",
"=",
"IntrospectionHandler",
"(",
"replaceKnownInterfaces",
")",
"xmlStr",
"=",
"xmlStr",
".",
"strip",
"(",
")",
"if",
"xmlStr",
".",
"startswith",
"(",
"'<!DOCTYPE'",
")",
":",
"xmlStr",
"=",
"xmlStr",
"[",
"xmlStr",
".",
"find",
"(",
"'>'",
")",
"+",
"1",
":",
"]",
"# xml.sax.parseString( xmlStr, handler )",
"p",
"=",
"xml",
".",
"sax",
".",
"make_parser",
"(",
")",
"p",
".",
"setFeature",
"(",
"xml",
".",
"sax",
".",
"handler",
".",
"feature_validation",
",",
"False",
")",
"p",
".",
"setFeature",
"(",
"xml",
".",
"sax",
".",
"handler",
".",
"feature_external_ges",
",",
"False",
")",
"p",
".",
"setContentHandler",
"(",
"handler",
")",
"p",
".",
"parse",
"(",
"cStringIO",
"(",
"xmlStr",
")",
")",
"return",
"handler",
".",
"interfaces"
] | Parses the supplied Introspection XML string and returns a list of
L{interface.DBusInerface} instances representing the XML interface
definitions.
@type replaceKnownInterfaces: C{bool}
@param replaceKnownInterfaces: If true, pre-existing interface definitions
will be replaced by the contents of the
interfaces defined within the XML string
@rtype: C{list} of L{interface.DBusInerface} | [
"Parses",
"the",
"supplied",
"Introspection",
"XML",
"string",
"and",
"returns",
"a",
"list",
"of",
"L",
"{",
"interface",
".",
"DBusInerface",
"}",
"instances",
"representing",
"the",
"XML",
"interface",
"definitions",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/introspection.py#L75-L101 |
cocagne/txdbus | txdbus/bus.py | Bus.clientConnected | def clientConnected(self, proto):
"""
Called when a client connects to the bus. This method assigns the
new connection a unique bus name.
"""
proto.uniqueName = ':1.%d' % (self.next_id,)
self.next_id += 1
self.clients[proto.uniqueName] = proto | python | def clientConnected(self, proto):
"""
Called when a client connects to the bus. This method assigns the
new connection a unique bus name.
"""
proto.uniqueName = ':1.%d' % (self.next_id,)
self.next_id += 1
self.clients[proto.uniqueName] = proto | [
"def",
"clientConnected",
"(",
"self",
",",
"proto",
")",
":",
"proto",
".",
"uniqueName",
"=",
"':1.%d'",
"%",
"(",
"self",
".",
"next_id",
",",
")",
"self",
".",
"next_id",
"+=",
"1",
"self",
".",
"clients",
"[",
"proto",
".",
"uniqueName",
"]",
"=",
"proto"
] | Called when a client connects to the bus. This method assigns the
new connection a unique bus name. | [
"Called",
"when",
"a",
"client",
"connects",
"to",
"the",
"bus",
".",
"This",
"method",
"assigns",
"the",
"new",
"connection",
"a",
"unique",
"bus",
"name",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/bus.py#L174-L181 |
cocagne/txdbus | txdbus/bus.py | Bus.clientDisconnected | def clientDisconnected(self, proto):
"""
Called when a client disconnects from the bus
"""
for rule_id in proto.matchRules:
self.router.delMatch(rule_id)
for busName in proto.busNames.keys():
self.dbus_ReleaseName(busName, proto.uniqueName)
if proto.uniqueName:
del self.clients[proto.uniqueName] | python | def clientDisconnected(self, proto):
"""
Called when a client disconnects from the bus
"""
for rule_id in proto.matchRules:
self.router.delMatch(rule_id)
for busName in proto.busNames.keys():
self.dbus_ReleaseName(busName, proto.uniqueName)
if proto.uniqueName:
del self.clients[proto.uniqueName] | [
"def",
"clientDisconnected",
"(",
"self",
",",
"proto",
")",
":",
"for",
"rule_id",
"in",
"proto",
".",
"matchRules",
":",
"self",
".",
"router",
".",
"delMatch",
"(",
"rule_id",
")",
"for",
"busName",
"in",
"proto",
".",
"busNames",
".",
"keys",
"(",
")",
":",
"self",
".",
"dbus_ReleaseName",
"(",
"busName",
",",
"proto",
".",
"uniqueName",
")",
"if",
"proto",
".",
"uniqueName",
":",
"del",
"self",
".",
"clients",
"[",
"proto",
".",
"uniqueName",
"]"
] | Called when a client disconnects from the bus | [
"Called",
"when",
"a",
"client",
"disconnects",
"from",
"the",
"bus"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/bus.py#L183-L194 |
cocagne/txdbus | txdbus/bus.py | Bus.sendMessage | def sendMessage(self, msg):
"""
Sends the supplied message to the correct destination. The
@type msg: L{message.DBusMessage}
@param msg: The 'destination' field of the message must be set for
method calls and returns
"""
if msg._messageType in (1, 2):
assert msg.destination, 'Failed to specify a message destination'
if msg.destination is not None:
if msg.destination[0] == ':':
p = self.clients.get(msg.destination, None)
else:
p = self.busNames.get(msg.destination, None)
if p:
p = p[0]
# print 'SND: ', msg._messageType, ' to ', p.uniqueName, 'serial',
# msg.serial,
if p:
p.sendMessage(msg)
else:
log.msg(
'Invalid bus name in msg.destination: '
+ msg.destination
)
else:
self.router.routeMessage(msg) | python | def sendMessage(self, msg):
"""
Sends the supplied message to the correct destination. The
@type msg: L{message.DBusMessage}
@param msg: The 'destination' field of the message must be set for
method calls and returns
"""
if msg._messageType in (1, 2):
assert msg.destination, 'Failed to specify a message destination'
if msg.destination is not None:
if msg.destination[0] == ':':
p = self.clients.get(msg.destination, None)
else:
p = self.busNames.get(msg.destination, None)
if p:
p = p[0]
# print 'SND: ', msg._messageType, ' to ', p.uniqueName, 'serial',
# msg.serial,
if p:
p.sendMessage(msg)
else:
log.msg(
'Invalid bus name in msg.destination: '
+ msg.destination
)
else:
self.router.routeMessage(msg) | [
"def",
"sendMessage",
"(",
"self",
",",
"msg",
")",
":",
"if",
"msg",
".",
"_messageType",
"in",
"(",
"1",
",",
"2",
")",
":",
"assert",
"msg",
".",
"destination",
",",
"'Failed to specify a message destination'",
"if",
"msg",
".",
"destination",
"is",
"not",
"None",
":",
"if",
"msg",
".",
"destination",
"[",
"0",
"]",
"==",
"':'",
":",
"p",
"=",
"self",
".",
"clients",
".",
"get",
"(",
"msg",
".",
"destination",
",",
"None",
")",
"else",
":",
"p",
"=",
"self",
".",
"busNames",
".",
"get",
"(",
"msg",
".",
"destination",
",",
"None",
")",
"if",
"p",
":",
"p",
"=",
"p",
"[",
"0",
"]",
"# print 'SND: ', msg._messageType, ' to ', p.uniqueName, 'serial',",
"# msg.serial,",
"if",
"p",
":",
"p",
".",
"sendMessage",
"(",
"msg",
")",
"else",
":",
"log",
".",
"msg",
"(",
"'Invalid bus name in msg.destination: '",
"+",
"msg",
".",
"destination",
")",
"else",
":",
"self",
".",
"router",
".",
"routeMessage",
"(",
"msg",
")"
] | Sends the supplied message to the correct destination. The
@type msg: L{message.DBusMessage}
@param msg: The 'destination' field of the message must be set for
method calls and returns | [
"Sends",
"the",
"supplied",
"message",
"to",
"the",
"correct",
"destination",
".",
"The"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/bus.py#L196-L225 |
cocagne/txdbus | txdbus/bus.py | Bus.sendSignal | def sendSignal(self, p, member, signature=None, body=None,
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus'):
"""
Sends a signal to a specific connection
@type p: L{BusProtocol}
@param p: L{BusProtocol} instance to send a signal to
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied, this parameter must be provided.
"""
if not isinstance(body, (list, tuple)):
body = [body]
s = message.SignalMessage(path, member, interface,
p.uniqueName, signature, body)
p.sendMessage(s) | python | def sendSignal(self, p, member, signature=None, body=None,
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus'):
"""
Sends a signal to a specific connection
@type p: L{BusProtocol}
@param p: L{BusProtocol} instance to send a signal to
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied, this parameter must be provided.
"""
if not isinstance(body, (list, tuple)):
body = [body]
s = message.SignalMessage(path, member, interface,
p.uniqueName, signature, body)
p.sendMessage(s) | [
"def",
"sendSignal",
"(",
"self",
",",
"p",
",",
"member",
",",
"signature",
"=",
"None",
",",
"body",
"=",
"None",
",",
"path",
"=",
"'/org/freedesktop/DBus'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
")",
":",
"if",
"not",
"isinstance",
"(",
"body",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"body",
"=",
"[",
"body",
"]",
"s",
"=",
"message",
".",
"SignalMessage",
"(",
"path",
",",
"member",
",",
"interface",
",",
"p",
".",
"uniqueName",
",",
"signature",
",",
"body",
")",
"p",
".",
"sendMessage",
"(",
"s",
")"
] | Sends a signal to a specific connection
@type p: L{BusProtocol}
@param p: L{BusProtocol} instance to send a signal to
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied, this parameter must be provided. | [
"Sends",
"a",
"signal",
"to",
"a",
"specific",
"connection"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/bus.py#L277-L312 |
cocagne/txdbus | txdbus/bus.py | Bus.broadcastSignal | def broadcastSignal(self, member, signature=None, body=None,
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus'):
"""
Sends a signal to all connections with registered interest
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied , this parameter must be provided.
"""
if not isinstance(body, (list, tuple)):
body = [body]
s = message.SignalMessage(path, member, interface,
None, signature, body)
self.router.routeMessage(s) | python | def broadcastSignal(self, member, signature=None, body=None,
path='/org/freedesktop/DBus',
interface='org.freedesktop.DBus'):
"""
Sends a signal to all connections with registered interest
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied , this parameter must be provided.
"""
if not isinstance(body, (list, tuple)):
body = [body]
s = message.SignalMessage(path, member, interface,
None, signature, body)
self.router.routeMessage(s) | [
"def",
"broadcastSignal",
"(",
"self",
",",
"member",
",",
"signature",
"=",
"None",
",",
"body",
"=",
"None",
",",
"path",
"=",
"'/org/freedesktop/DBus'",
",",
"interface",
"=",
"'org.freedesktop.DBus'",
")",
":",
"if",
"not",
"isinstance",
"(",
"body",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"body",
"=",
"[",
"body",
"]",
"s",
"=",
"message",
".",
"SignalMessage",
"(",
"path",
",",
"member",
",",
"interface",
",",
"None",
",",
"signature",
",",
"body",
")",
"self",
".",
"router",
".",
"routeMessage",
"(",
"s",
")"
] | Sends a signal to all connections with registered interest
@type member: C{string}
@param member: Name of the signal to send
@type path: C{string}
@param path: Path of the object emitting the signal. Defaults to
'org/freedesktop/DBus'
@type interface: C{string}
@param interface: If specified, this specifies the interface containing
the desired method. Defaults to 'org.freedesktop.DBus'
@type body: None or C{list}
@param body: If supplied, this is a list of signal arguments. The
contents of the list must match the signature.
@type signature: None or C{string}
@param signature: If specified, this specifies the DBus signature of
the body of the DBus Signal message. This string must be a valid
Signature string as defined by the DBus specification. If the body
argumnent is supplied , this parameter must be provided. | [
"Sends",
"a",
"signal",
"to",
"all",
"connections",
"with",
"registered",
"interest"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/bus.py#L314-L346 |
cocagne/txdbus | txdbus/message.py | parseMessage | def parseMessage(rawMessage, oobFDs):
"""
Parses the raw binary message and returns a L{DBusMessage} subclass.
Unmarshalling DBUS 'h' (UNIX_FD) gets the FDs from the oobFDs list.
@type rawMessage: C{str}
@param rawMessage: Raw binary message to parse
@rtype: L{DBusMessage} subclass
@returns: The L{DBusMessage} subclass corresponding to the contained
message
"""
lendian = rawMessage[0] == b'l'[0]
nheader, hval = marshal.unmarshal(
_headerFormat,
rawMessage,
0,
lendian,
oobFDs,
)
messageType = hval[1]
if messageType not in _mtype:
raise error.MarshallingError(
'Unknown Message Type: ' + str(messageType)
)
m = object.__new__(_mtype[messageType])
m.rawHeader = rawMessage[:nheader]
npad = nheader % 8 and (8 - nheader % 8) or 0
m.rawPadding = rawMessage[nheader: nheader + npad]
m.rawBody = rawMessage[nheader + npad:]
m.serial = hval[5]
for code, v in hval[6]:
try:
setattr(m, _hcode[code], v)
except KeyError:
pass
if m.signature:
nbytes, m.body = marshal.unmarshal(
m.signature,
m.rawBody,
lendian=lendian,
oobFDs=oobFDs,
)
return m | python | def parseMessage(rawMessage, oobFDs):
"""
Parses the raw binary message and returns a L{DBusMessage} subclass.
Unmarshalling DBUS 'h' (UNIX_FD) gets the FDs from the oobFDs list.
@type rawMessage: C{str}
@param rawMessage: Raw binary message to parse
@rtype: L{DBusMessage} subclass
@returns: The L{DBusMessage} subclass corresponding to the contained
message
"""
lendian = rawMessage[0] == b'l'[0]
nheader, hval = marshal.unmarshal(
_headerFormat,
rawMessage,
0,
lendian,
oobFDs,
)
messageType = hval[1]
if messageType not in _mtype:
raise error.MarshallingError(
'Unknown Message Type: ' + str(messageType)
)
m = object.__new__(_mtype[messageType])
m.rawHeader = rawMessage[:nheader]
npad = nheader % 8 and (8 - nheader % 8) or 0
m.rawPadding = rawMessage[nheader: nheader + npad]
m.rawBody = rawMessage[nheader + npad:]
m.serial = hval[5]
for code, v in hval[6]:
try:
setattr(m, _hcode[code], v)
except KeyError:
pass
if m.signature:
nbytes, m.body = marshal.unmarshal(
m.signature,
m.rawBody,
lendian=lendian,
oobFDs=oobFDs,
)
return m | [
"def",
"parseMessage",
"(",
"rawMessage",
",",
"oobFDs",
")",
":",
"lendian",
"=",
"rawMessage",
"[",
"0",
"]",
"==",
"b'l'",
"[",
"0",
"]",
"nheader",
",",
"hval",
"=",
"marshal",
".",
"unmarshal",
"(",
"_headerFormat",
",",
"rawMessage",
",",
"0",
",",
"lendian",
",",
"oobFDs",
",",
")",
"messageType",
"=",
"hval",
"[",
"1",
"]",
"if",
"messageType",
"not",
"in",
"_mtype",
":",
"raise",
"error",
".",
"MarshallingError",
"(",
"'Unknown Message Type: '",
"+",
"str",
"(",
"messageType",
")",
")",
"m",
"=",
"object",
".",
"__new__",
"(",
"_mtype",
"[",
"messageType",
"]",
")",
"m",
".",
"rawHeader",
"=",
"rawMessage",
"[",
":",
"nheader",
"]",
"npad",
"=",
"nheader",
"%",
"8",
"and",
"(",
"8",
"-",
"nheader",
"%",
"8",
")",
"or",
"0",
"m",
".",
"rawPadding",
"=",
"rawMessage",
"[",
"nheader",
":",
"nheader",
"+",
"npad",
"]",
"m",
".",
"rawBody",
"=",
"rawMessage",
"[",
"nheader",
"+",
"npad",
":",
"]",
"m",
".",
"serial",
"=",
"hval",
"[",
"5",
"]",
"for",
"code",
",",
"v",
"in",
"hval",
"[",
"6",
"]",
":",
"try",
":",
"setattr",
"(",
"m",
",",
"_hcode",
"[",
"code",
"]",
",",
"v",
")",
"except",
"KeyError",
":",
"pass",
"if",
"m",
".",
"signature",
":",
"nbytes",
",",
"m",
".",
"body",
"=",
"marshal",
".",
"unmarshal",
"(",
"m",
".",
"signature",
",",
"m",
".",
"rawBody",
",",
"lendian",
"=",
"lendian",
",",
"oobFDs",
"=",
"oobFDs",
",",
")",
"return",
"m"
] | Parses the raw binary message and returns a L{DBusMessage} subclass.
Unmarshalling DBUS 'h' (UNIX_FD) gets the FDs from the oobFDs list.
@type rawMessage: C{str}
@param rawMessage: Raw binary message to parse
@rtype: L{DBusMessage} subclass
@returns: The L{DBusMessage} subclass corresponding to the contained
message | [
"Parses",
"the",
"raw",
"binary",
"message",
"and",
"returns",
"a",
"L",
"{",
"DBusMessage",
"}",
"subclass",
".",
"Unmarshalling",
"DBUS",
"h",
"(",
"UNIX_FD",
")",
"gets",
"the",
"FDs",
"from",
"the",
"oobFDs",
"list",
"."
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/message.py#L354-L410 |
cocagne/txdbus | txdbus/message.py | DBusMessage._marshal | def _marshal(self, newSerial=True, oobFDs=None):
"""
Encodes the message into binary format. The resulting binary message is
stored in C{self.rawMessage}
"""
flags = 0
if not self.expectReply:
flags |= 0x1
if not self.autoStart:
flags |= 0x2
# may be overriden below, depending on oobFDs
_headerAttrs = self._headerAttrs
# marshal body before headers to know if the 'unix_fd' header is needed
if self.signature:
binBody = b''.join(
marshal.marshal(
self.signature,
self.body,
oobFDs=oobFDs
)[1]
)
if oobFDs:
# copy class based _headerAttrs to add a unix_fds header this
# time
_headerAttrs = list(self._headerAttrs)
_headerAttrs.append(('unix_fds', 9, False))
self.unix_fds = len(oobFDs)
else:
binBody = b''
self.headers = []
for attr_name, code, _ in _headerAttrs:
hval = getattr(self, attr_name, None)
if hval is not None:
if attr_name == 'path':
hval = marshal.ObjectPath(hval)
elif attr_name == 'signature':
hval = marshal.Signature(hval)
elif attr_name == 'unix_fds':
hval = marshal.UInt32(hval)
self.headers.append([code, hval])
self.bodyLength = len(binBody)
if newSerial:
self.serial = DBusMessage._nextSerial
DBusMessage._nextSerial += 1
binHeader = b''.join(marshal.marshal(
_headerFormat,
[
self.endian,
self._messageType,
flags,
self._protocolVersion,
self.bodyLength,
self.serial,
self.headers
],
lendian=self.endian == ord('l')
)[1])
headerPadding = marshal.pad['header'](len(binHeader))
self.rawHeader = binHeader
self.rawPadding = headerPadding
self.rawBody = binBody
self.rawMessage = b''.join([binHeader, headerPadding, binBody])
if len(self.rawMessage) > self._maxMsgLen:
raise error.MarshallingError(
'Marshalled message exceeds maximum message size of %d' %
(self._maxMsgLen,),
) | python | def _marshal(self, newSerial=True, oobFDs=None):
"""
Encodes the message into binary format. The resulting binary message is
stored in C{self.rawMessage}
"""
flags = 0
if not self.expectReply:
flags |= 0x1
if not self.autoStart:
flags |= 0x2
# may be overriden below, depending on oobFDs
_headerAttrs = self._headerAttrs
# marshal body before headers to know if the 'unix_fd' header is needed
if self.signature:
binBody = b''.join(
marshal.marshal(
self.signature,
self.body,
oobFDs=oobFDs
)[1]
)
if oobFDs:
# copy class based _headerAttrs to add a unix_fds header this
# time
_headerAttrs = list(self._headerAttrs)
_headerAttrs.append(('unix_fds', 9, False))
self.unix_fds = len(oobFDs)
else:
binBody = b''
self.headers = []
for attr_name, code, _ in _headerAttrs:
hval = getattr(self, attr_name, None)
if hval is not None:
if attr_name == 'path':
hval = marshal.ObjectPath(hval)
elif attr_name == 'signature':
hval = marshal.Signature(hval)
elif attr_name == 'unix_fds':
hval = marshal.UInt32(hval)
self.headers.append([code, hval])
self.bodyLength = len(binBody)
if newSerial:
self.serial = DBusMessage._nextSerial
DBusMessage._nextSerial += 1
binHeader = b''.join(marshal.marshal(
_headerFormat,
[
self.endian,
self._messageType,
flags,
self._protocolVersion,
self.bodyLength,
self.serial,
self.headers
],
lendian=self.endian == ord('l')
)[1])
headerPadding = marshal.pad['header'](len(binHeader))
self.rawHeader = binHeader
self.rawPadding = headerPadding
self.rawBody = binBody
self.rawMessage = b''.join([binHeader, headerPadding, binBody])
if len(self.rawMessage) > self._maxMsgLen:
raise error.MarshallingError(
'Marshalled message exceeds maximum message size of %d' %
(self._maxMsgLen,),
) | [
"def",
"_marshal",
"(",
"self",
",",
"newSerial",
"=",
"True",
",",
"oobFDs",
"=",
"None",
")",
":",
"flags",
"=",
"0",
"if",
"not",
"self",
".",
"expectReply",
":",
"flags",
"|=",
"0x1",
"if",
"not",
"self",
".",
"autoStart",
":",
"flags",
"|=",
"0x2",
"# may be overriden below, depending on oobFDs",
"_headerAttrs",
"=",
"self",
".",
"_headerAttrs",
"# marshal body before headers to know if the 'unix_fd' header is needed",
"if",
"self",
".",
"signature",
":",
"binBody",
"=",
"b''",
".",
"join",
"(",
"marshal",
".",
"marshal",
"(",
"self",
".",
"signature",
",",
"self",
".",
"body",
",",
"oobFDs",
"=",
"oobFDs",
")",
"[",
"1",
"]",
")",
"if",
"oobFDs",
":",
"# copy class based _headerAttrs to add a unix_fds header this",
"# time",
"_headerAttrs",
"=",
"list",
"(",
"self",
".",
"_headerAttrs",
")",
"_headerAttrs",
".",
"append",
"(",
"(",
"'unix_fds'",
",",
"9",
",",
"False",
")",
")",
"self",
".",
"unix_fds",
"=",
"len",
"(",
"oobFDs",
")",
"else",
":",
"binBody",
"=",
"b''",
"self",
".",
"headers",
"=",
"[",
"]",
"for",
"attr_name",
",",
"code",
",",
"_",
"in",
"_headerAttrs",
":",
"hval",
"=",
"getattr",
"(",
"self",
",",
"attr_name",
",",
"None",
")",
"if",
"hval",
"is",
"not",
"None",
":",
"if",
"attr_name",
"==",
"'path'",
":",
"hval",
"=",
"marshal",
".",
"ObjectPath",
"(",
"hval",
")",
"elif",
"attr_name",
"==",
"'signature'",
":",
"hval",
"=",
"marshal",
".",
"Signature",
"(",
"hval",
")",
"elif",
"attr_name",
"==",
"'unix_fds'",
":",
"hval",
"=",
"marshal",
".",
"UInt32",
"(",
"hval",
")",
"self",
".",
"headers",
".",
"append",
"(",
"[",
"code",
",",
"hval",
"]",
")",
"self",
".",
"bodyLength",
"=",
"len",
"(",
"binBody",
")",
"if",
"newSerial",
":",
"self",
".",
"serial",
"=",
"DBusMessage",
".",
"_nextSerial",
"DBusMessage",
".",
"_nextSerial",
"+=",
"1",
"binHeader",
"=",
"b''",
".",
"join",
"(",
"marshal",
".",
"marshal",
"(",
"_headerFormat",
",",
"[",
"self",
".",
"endian",
",",
"self",
".",
"_messageType",
",",
"flags",
",",
"self",
".",
"_protocolVersion",
",",
"self",
".",
"bodyLength",
",",
"self",
".",
"serial",
",",
"self",
".",
"headers",
"]",
",",
"lendian",
"=",
"self",
".",
"endian",
"==",
"ord",
"(",
"'l'",
")",
")",
"[",
"1",
"]",
")",
"headerPadding",
"=",
"marshal",
".",
"pad",
"[",
"'header'",
"]",
"(",
"len",
"(",
"binHeader",
")",
")",
"self",
".",
"rawHeader",
"=",
"binHeader",
"self",
".",
"rawPadding",
"=",
"headerPadding",
"self",
".",
"rawBody",
"=",
"binBody",
"self",
".",
"rawMessage",
"=",
"b''",
".",
"join",
"(",
"[",
"binHeader",
",",
"headerPadding",
",",
"binBody",
"]",
")",
"if",
"len",
"(",
"self",
".",
"rawMessage",
")",
">",
"self",
".",
"_maxMsgLen",
":",
"raise",
"error",
".",
"MarshallingError",
"(",
"'Marshalled message exceeds maximum message size of %d'",
"%",
"(",
"self",
".",
"_maxMsgLen",
",",
")",
",",
")"
] | Encodes the message into binary format. The resulting binary message is
stored in C{self.rawMessage} | [
"Encodes",
"the",
"message",
"into",
"binary",
"format",
".",
"The",
"resulting",
"binary",
"message",
"is",
"stored",
"in",
"C",
"{",
"self",
".",
"rawMessage",
"}"
] | train | https://github.com/cocagne/txdbus/blob/eb424918764b7b93eecd2a4e2e5c2d0b2944407b/txdbus/message.py#L74-L156 |
tonyo/pyope | pyope/ope.py | OPE.encrypt | def encrypt(self, plaintext):
"""Encrypt the given plaintext value"""
if not isinstance(plaintext, int):
raise ValueError('Plaintext must be an integer value')
if not self.in_range.contains(plaintext):
raise OutOfRangeError('Plaintext is not within the input range')
return self.encrypt_recursive(plaintext, self.in_range, self.out_range) | python | def encrypt(self, plaintext):
"""Encrypt the given plaintext value"""
if not isinstance(plaintext, int):
raise ValueError('Plaintext must be an integer value')
if not self.in_range.contains(plaintext):
raise OutOfRangeError('Plaintext is not within the input range')
return self.encrypt_recursive(plaintext, self.in_range, self.out_range) | [
"def",
"encrypt",
"(",
"self",
",",
"plaintext",
")",
":",
"if",
"not",
"isinstance",
"(",
"plaintext",
",",
"int",
")",
":",
"raise",
"ValueError",
"(",
"'Plaintext must be an integer value'",
")",
"if",
"not",
"self",
".",
"in_range",
".",
"contains",
"(",
"plaintext",
")",
":",
"raise",
"OutOfRangeError",
"(",
"'Plaintext is not within the input range'",
")",
"return",
"self",
".",
"encrypt_recursive",
"(",
"plaintext",
",",
"self",
".",
"in_range",
",",
"self",
".",
"out_range",
")"
] | Encrypt the given plaintext value | [
"Encrypt",
"the",
"given",
"plaintext",
"value"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/ope.py#L100-L106 |
tonyo/pyope | pyope/ope.py | OPE.decrypt | def decrypt(self, ciphertext):
"""Decrypt the given ciphertext value"""
if not isinstance(ciphertext, int):
raise ValueError('Ciphertext must be an integer value')
if not self.out_range.contains(ciphertext):
raise OutOfRangeError('Ciphertext is not within the output range')
return self.decrypt_recursive(ciphertext, self.in_range, self.out_range) | python | def decrypt(self, ciphertext):
"""Decrypt the given ciphertext value"""
if not isinstance(ciphertext, int):
raise ValueError('Ciphertext must be an integer value')
if not self.out_range.contains(ciphertext):
raise OutOfRangeError('Ciphertext is not within the output range')
return self.decrypt_recursive(ciphertext, self.in_range, self.out_range) | [
"def",
"decrypt",
"(",
"self",
",",
"ciphertext",
")",
":",
"if",
"not",
"isinstance",
"(",
"ciphertext",
",",
"int",
")",
":",
"raise",
"ValueError",
"(",
"'Ciphertext must be an integer value'",
")",
"if",
"not",
"self",
".",
"out_range",
".",
"contains",
"(",
"ciphertext",
")",
":",
"raise",
"OutOfRangeError",
"(",
"'Ciphertext is not within the output range'",
")",
"return",
"self",
".",
"decrypt_recursive",
"(",
"ciphertext",
",",
"self",
".",
"in_range",
",",
"self",
".",
"out_range",
")"
] | Decrypt the given ciphertext value | [
"Decrypt",
"the",
"given",
"ciphertext",
"value"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/ope.py#L130-L136 |
tonyo/pyope | pyope/ope.py | OPE.tape_gen | def tape_gen(self, data):
"""Return a bit string, generated from the given data string"""
# FIXME
data = str(data).encode()
# Derive a key from data
hmac_obj = hmac.HMAC(self.key, digestmod=hashlib.sha256)
hmac_obj.update(data)
assert hmac_obj.digest_size == 32
digest = hmac_obj.digest()
# Use AES in the CTR mode to generate a pseudo-random bit string
aes_algo = algorithms.AES(digest)
aes_cipher = Cipher(aes_algo, mode=CTR(b'\x00' * 16), backend=default_backend())
encryptor = aes_cipher.encryptor()
while True:
encrypted_bytes = encryptor.update(b'\x00' * 16)
# Convert the data to a list of bits
bits = util.str_to_bitstring(encrypted_bytes)
for bit in bits:
yield bit | python | def tape_gen(self, data):
"""Return a bit string, generated from the given data string"""
# FIXME
data = str(data).encode()
# Derive a key from data
hmac_obj = hmac.HMAC(self.key, digestmod=hashlib.sha256)
hmac_obj.update(data)
assert hmac_obj.digest_size == 32
digest = hmac_obj.digest()
# Use AES in the CTR mode to generate a pseudo-random bit string
aes_algo = algorithms.AES(digest)
aes_cipher = Cipher(aes_algo, mode=CTR(b'\x00' * 16), backend=default_backend())
encryptor = aes_cipher.encryptor()
while True:
encrypted_bytes = encryptor.update(b'\x00' * 16)
# Convert the data to a list of bits
bits = util.str_to_bitstring(encrypted_bytes)
for bit in bits:
yield bit | [
"def",
"tape_gen",
"(",
"self",
",",
"data",
")",
":",
"# FIXME",
"data",
"=",
"str",
"(",
"data",
")",
".",
"encode",
"(",
")",
"# Derive a key from data",
"hmac_obj",
"=",
"hmac",
".",
"HMAC",
"(",
"self",
".",
"key",
",",
"digestmod",
"=",
"hashlib",
".",
"sha256",
")",
"hmac_obj",
".",
"update",
"(",
"data",
")",
"assert",
"hmac_obj",
".",
"digest_size",
"==",
"32",
"digest",
"=",
"hmac_obj",
".",
"digest",
"(",
")",
"# Use AES in the CTR mode to generate a pseudo-random bit string",
"aes_algo",
"=",
"algorithms",
".",
"AES",
"(",
"digest",
")",
"aes_cipher",
"=",
"Cipher",
"(",
"aes_algo",
",",
"mode",
"=",
"CTR",
"(",
"b'\\x00'",
"*",
"16",
")",
",",
"backend",
"=",
"default_backend",
"(",
")",
")",
"encryptor",
"=",
"aes_cipher",
".",
"encryptor",
"(",
")",
"while",
"True",
":",
"encrypted_bytes",
"=",
"encryptor",
".",
"update",
"(",
"b'\\x00'",
"*",
"16",
")",
"# Convert the data to a list of bits",
"bits",
"=",
"util",
".",
"str_to_bitstring",
"(",
"encrypted_bytes",
")",
"for",
"bit",
"in",
"bits",
":",
"yield",
"bit"
] | Return a bit string, generated from the given data string | [
"Return",
"a",
"bit",
"string",
"generated",
"from",
"the",
"given",
"data",
"string"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/ope.py#L164-L186 |
tonyo/pyope | pyope/ope.py | OPE.generate_key | def generate_key(block_size=32):
"""Generate random key for ope cipher.
Parameters
----------
block_size : int, optional
Length of random bytes.
Returns
-------
random_key : str
A random key for encryption.
Notes:
------
Implementation follows https://github.com/pyca/cryptography
"""
random_seq = os.urandom(block_size)
random_key = base64.b64encode(random_seq)
return random_key | python | def generate_key(block_size=32):
"""Generate random key for ope cipher.
Parameters
----------
block_size : int, optional
Length of random bytes.
Returns
-------
random_key : str
A random key for encryption.
Notes:
------
Implementation follows https://github.com/pyca/cryptography
"""
random_seq = os.urandom(block_size)
random_key = base64.b64encode(random_seq)
return random_key | [
"def",
"generate_key",
"(",
"block_size",
"=",
"32",
")",
":",
"random_seq",
"=",
"os",
".",
"urandom",
"(",
"block_size",
")",
"random_key",
"=",
"base64",
".",
"b64encode",
"(",
"random_seq",
")",
"return",
"random_key"
] | Generate random key for ope cipher.
Parameters
----------
block_size : int, optional
Length of random bytes.
Returns
-------
random_key : str
A random key for encryption.
Notes:
------
Implementation follows https://github.com/pyca/cryptography | [
"Generate",
"random",
"key",
"for",
"ope",
"cipher",
"."
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/ope.py#L189-L208 |
tonyo/pyope | pyope/util.py | byte_to_bitstring | def byte_to_bitstring(byte):
"""Convert one byte to a list of bits"""
assert 0 <= byte <= 0xff
bits = [int(x) for x in list(bin(byte + 0x100)[3:])]
return bits | python | def byte_to_bitstring(byte):
"""Convert one byte to a list of bits"""
assert 0 <= byte <= 0xff
bits = [int(x) for x in list(bin(byte + 0x100)[3:])]
return bits | [
"def",
"byte_to_bitstring",
"(",
"byte",
")",
":",
"assert",
"0",
"<=",
"byte",
"<=",
"0xff",
"bits",
"=",
"[",
"int",
"(",
"x",
")",
"for",
"x",
"in",
"list",
"(",
"bin",
"(",
"byte",
"+",
"0x100",
")",
"[",
"3",
":",
"]",
")",
"]",
"return",
"bits"
] | Convert one byte to a list of bits | [
"Convert",
"one",
"byte",
"to",
"a",
"list",
"of",
"bits"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/util.py#L3-L7 |
tonyo/pyope | pyope/util.py | str_to_bitstring | def str_to_bitstring(data):
"""Convert a string to a list of bits"""
assert isinstance(data, bytes), "Data must be an instance of bytes"
byte_list = data_to_byte_list(data)
bit_list = [bit for data_byte in byte_list for bit in byte_to_bitstring(data_byte)]
return bit_list | python | def str_to_bitstring(data):
"""Convert a string to a list of bits"""
assert isinstance(data, bytes), "Data must be an instance of bytes"
byte_list = data_to_byte_list(data)
bit_list = [bit for data_byte in byte_list for bit in byte_to_bitstring(data_byte)]
return bit_list | [
"def",
"str_to_bitstring",
"(",
"data",
")",
":",
"assert",
"isinstance",
"(",
"data",
",",
"bytes",
")",
",",
"\"Data must be an instance of bytes\"",
"byte_list",
"=",
"data_to_byte_list",
"(",
"data",
")",
"bit_list",
"=",
"[",
"bit",
"for",
"data_byte",
"in",
"byte_list",
"for",
"bit",
"in",
"byte_to_bitstring",
"(",
"data_byte",
")",
"]",
"return",
"bit_list"
] | Convert a string to a list of bits | [
"Convert",
"a",
"string",
"to",
"a",
"list",
"of",
"bits"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/util.py#L18-L23 |
tonyo/pyope | pyope/stat.py | sample_hgd | def sample_hgd(in_range, out_range, nsample, seed_coins):
"""Get a sample from the hypergeometric distribution, using the provided bit list as a source of randomness"""
in_size = in_range.size()
out_size = out_range.size()
assert in_size > 0 and out_size > 0
assert in_size <= out_size
assert out_range.contains(nsample)
# 1-based index of nsample in out_range
nsample_index = nsample - out_range.start + 1
if in_size == out_size:
# Input and output domains have equal size
return in_range.start + nsample_index - 1
in_sample_num = HGD.rhyper(nsample_index, in_size, out_size - in_size, seed_coins)
if in_sample_num == 0:
return in_range.start
else:
in_sample = in_range.start + in_sample_num - 1
assert in_range.contains(in_sample)
return in_sample | python | def sample_hgd(in_range, out_range, nsample, seed_coins):
"""Get a sample from the hypergeometric distribution, using the provided bit list as a source of randomness"""
in_size = in_range.size()
out_size = out_range.size()
assert in_size > 0 and out_size > 0
assert in_size <= out_size
assert out_range.contains(nsample)
# 1-based index of nsample in out_range
nsample_index = nsample - out_range.start + 1
if in_size == out_size:
# Input and output domains have equal size
return in_range.start + nsample_index - 1
in_sample_num = HGD.rhyper(nsample_index, in_size, out_size - in_size, seed_coins)
if in_sample_num == 0:
return in_range.start
else:
in_sample = in_range.start + in_sample_num - 1
assert in_range.contains(in_sample)
return in_sample | [
"def",
"sample_hgd",
"(",
"in_range",
",",
"out_range",
",",
"nsample",
",",
"seed_coins",
")",
":",
"in_size",
"=",
"in_range",
".",
"size",
"(",
")",
"out_size",
"=",
"out_range",
".",
"size",
"(",
")",
"assert",
"in_size",
">",
"0",
"and",
"out_size",
">",
"0",
"assert",
"in_size",
"<=",
"out_size",
"assert",
"out_range",
".",
"contains",
"(",
"nsample",
")",
"# 1-based index of nsample in out_range",
"nsample_index",
"=",
"nsample",
"-",
"out_range",
".",
"start",
"+",
"1",
"if",
"in_size",
"==",
"out_size",
":",
"# Input and output domains have equal size",
"return",
"in_range",
".",
"start",
"+",
"nsample_index",
"-",
"1",
"in_sample_num",
"=",
"HGD",
".",
"rhyper",
"(",
"nsample_index",
",",
"in_size",
",",
"out_size",
"-",
"in_size",
",",
"seed_coins",
")",
"if",
"in_sample_num",
"==",
"0",
":",
"return",
"in_range",
".",
"start",
"else",
":",
"in_sample",
"=",
"in_range",
".",
"start",
"+",
"in_sample_num",
"-",
"1",
"assert",
"in_range",
".",
"contains",
"(",
"in_sample",
")",
"return",
"in_sample"
] | Get a sample from the hypergeometric distribution, using the provided bit list as a source of randomness | [
"Get",
"a",
"sample",
"from",
"the",
"hypergeometric",
"distribution",
"using",
"the",
"provided",
"bit",
"list",
"as",
"a",
"source",
"of",
"randomness"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/stat.py#L5-L25 |
tonyo/pyope | pyope/stat.py | sample_uniform | def sample_uniform(in_range, seed_coins):
"""Uniformly select a number from the range using the bit list as a source of randomness"""
if isinstance(seed_coins, list):
seed_coins.append(None)
seed_coins = iter(seed_coins)
cur_range = in_range.copy()
assert cur_range.size() != 0
while cur_range.size() > 1:
mid = (cur_range.start + cur_range.end) // 2
bit = next(seed_coins)
if bit == 0:
cur_range.end = mid
elif bit == 1:
cur_range.start = mid + 1
elif bit is None:
raise NotEnoughCoinsError()
else:
raise InvalidCoinError()
assert cur_range.size() == 1
return cur_range.start | python | def sample_uniform(in_range, seed_coins):
"""Uniformly select a number from the range using the bit list as a source of randomness"""
if isinstance(seed_coins, list):
seed_coins.append(None)
seed_coins = iter(seed_coins)
cur_range = in_range.copy()
assert cur_range.size() != 0
while cur_range.size() > 1:
mid = (cur_range.start + cur_range.end) // 2
bit = next(seed_coins)
if bit == 0:
cur_range.end = mid
elif bit == 1:
cur_range.start = mid + 1
elif bit is None:
raise NotEnoughCoinsError()
else:
raise InvalidCoinError()
assert cur_range.size() == 1
return cur_range.start | [
"def",
"sample_uniform",
"(",
"in_range",
",",
"seed_coins",
")",
":",
"if",
"isinstance",
"(",
"seed_coins",
",",
"list",
")",
":",
"seed_coins",
".",
"append",
"(",
"None",
")",
"seed_coins",
"=",
"iter",
"(",
"seed_coins",
")",
"cur_range",
"=",
"in_range",
".",
"copy",
"(",
")",
"assert",
"cur_range",
".",
"size",
"(",
")",
"!=",
"0",
"while",
"cur_range",
".",
"size",
"(",
")",
">",
"1",
":",
"mid",
"=",
"(",
"cur_range",
".",
"start",
"+",
"cur_range",
".",
"end",
")",
"//",
"2",
"bit",
"=",
"next",
"(",
"seed_coins",
")",
"if",
"bit",
"==",
"0",
":",
"cur_range",
".",
"end",
"=",
"mid",
"elif",
"bit",
"==",
"1",
":",
"cur_range",
".",
"start",
"=",
"mid",
"+",
"1",
"elif",
"bit",
"is",
"None",
":",
"raise",
"NotEnoughCoinsError",
"(",
")",
"else",
":",
"raise",
"InvalidCoinError",
"(",
")",
"assert",
"cur_range",
".",
"size",
"(",
")",
"==",
"1",
"return",
"cur_range",
".",
"start"
] | Uniformly select a number from the range using the bit list as a source of randomness | [
"Uniformly",
"select",
"a",
"number",
"from",
"the",
"range",
"using",
"the",
"bit",
"list",
"as",
"a",
"source",
"of",
"randomness"
] | train | https://github.com/tonyo/pyope/blob/1e9f9f15cd4b989d1bf3c607270bf6a8ae808b1e/pyope/stat.py#L28-L47 |
dustin/twitty-twister | twittytwister/twitter.py | __downloadPage | def __downloadPage(factory, *args, **kwargs):
"""Start a HTTP download, returning a HTTPDownloader object"""
# The Twisted API is weird:
# 1) web.client.downloadPage() doesn't give us the HTTP headers
# 2) there is no method that simply accepts a URL and gives you back
# a HTTPDownloader object
#TODO: convert getPage() usage to something similar, too
downloader = factory(*args, **kwargs)
if downloader.scheme == 'https':
from twisted.internet import ssl
contextFactory = ssl.ClientContextFactory()
reactor.connectSSL(downloader.host, downloader.port,
downloader, contextFactory)
else:
reactor.connectTCP(downloader.host, downloader.port,
downloader)
return downloader | python | def __downloadPage(factory, *args, **kwargs):
"""Start a HTTP download, returning a HTTPDownloader object"""
# The Twisted API is weird:
# 1) web.client.downloadPage() doesn't give us the HTTP headers
# 2) there is no method that simply accepts a URL and gives you back
# a HTTPDownloader object
#TODO: convert getPage() usage to something similar, too
downloader = factory(*args, **kwargs)
if downloader.scheme == 'https':
from twisted.internet import ssl
contextFactory = ssl.ClientContextFactory()
reactor.connectSSL(downloader.host, downloader.port,
downloader, contextFactory)
else:
reactor.connectTCP(downloader.host, downloader.port,
downloader)
return downloader | [
"def",
"__downloadPage",
"(",
"factory",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"# The Twisted API is weird:",
"# 1) web.client.downloadPage() doesn't give us the HTTP headers",
"# 2) there is no method that simply accepts a URL and gives you back",
"# a HTTPDownloader object",
"#TODO: convert getPage() usage to something similar, too",
"downloader",
"=",
"factory",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"downloader",
".",
"scheme",
"==",
"'https'",
":",
"from",
"twisted",
".",
"internet",
"import",
"ssl",
"contextFactory",
"=",
"ssl",
".",
"ClientContextFactory",
"(",
")",
"reactor",
".",
"connectSSL",
"(",
"downloader",
".",
"host",
",",
"downloader",
".",
"port",
",",
"downloader",
",",
"contextFactory",
")",
"else",
":",
"reactor",
".",
"connectTCP",
"(",
"downloader",
".",
"host",
",",
"downloader",
".",
"port",
",",
"downloader",
")",
"return",
"downloader"
] | Start a HTTP download, returning a HTTPDownloader object | [
"Start",
"a",
"HTTP",
"download",
"returning",
"a",
"HTTPDownloader",
"object"
] | train | https://github.com/dustin/twitty-twister/blob/8524750ee73adb57bbe14ef0cfd8aa08e1e59fb3/twittytwister/twitter.py#L76-L95 |
dustin/twitty-twister | twittytwister/twitter.py | Twitter.__encodeMultipart | def __encodeMultipart(self, fields, files):
"""
fields is a sequence of (name, value) elements for regular form fields.
files is a sequence of (name, filename, value) elements for data to be uploaded as files
Return (content_type, body) ready for httplib.HTTP instance
"""
boundary = mimetools.choose_boundary()
crlf = '\r\n'
l = []
for k, v in fields:
l.append('--' + boundary)
l.append('Content-Disposition: form-data; name="%s"' % k)
l.append('')
l.append(v)
for (k, f, v) in files:
l.append('--' + boundary)
l.append('Content-Disposition: form-data; name="%s"; filename="%s"' % (k, f))
l.append('Content-Type: %s' % self.__getContentType(f))
l.append('')
l.append(v)
l.append('--' + boundary + '--')
l.append('')
body = crlf.join(l)
return boundary, body | python | def __encodeMultipart(self, fields, files):
"""
fields is a sequence of (name, value) elements for regular form fields.
files is a sequence of (name, filename, value) elements for data to be uploaded as files
Return (content_type, body) ready for httplib.HTTP instance
"""
boundary = mimetools.choose_boundary()
crlf = '\r\n'
l = []
for k, v in fields:
l.append('--' + boundary)
l.append('Content-Disposition: form-data; name="%s"' % k)
l.append('')
l.append(v)
for (k, f, v) in files:
l.append('--' + boundary)
l.append('Content-Disposition: form-data; name="%s"; filename="%s"' % (k, f))
l.append('Content-Type: %s' % self.__getContentType(f))
l.append('')
l.append(v)
l.append('--' + boundary + '--')
l.append('')
body = crlf.join(l)
return boundary, body | [
"def",
"__encodeMultipart",
"(",
"self",
",",
"fields",
",",
"files",
")",
":",
"boundary",
"=",
"mimetools",
".",
"choose_boundary",
"(",
")",
"crlf",
"=",
"'\\r\\n'",
"l",
"=",
"[",
"]",
"for",
"k",
",",
"v",
"in",
"fields",
":",
"l",
".",
"append",
"(",
"'--'",
"+",
"boundary",
")",
"l",
".",
"append",
"(",
"'Content-Disposition: form-data; name=\"%s\"'",
"%",
"k",
")",
"l",
".",
"append",
"(",
"''",
")",
"l",
".",
"append",
"(",
"v",
")",
"for",
"(",
"k",
",",
"f",
",",
"v",
")",
"in",
"files",
":",
"l",
".",
"append",
"(",
"'--'",
"+",
"boundary",
")",
"l",
".",
"append",
"(",
"'Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"'",
"%",
"(",
"k",
",",
"f",
")",
")",
"l",
".",
"append",
"(",
"'Content-Type: %s'",
"%",
"self",
".",
"__getContentType",
"(",
"f",
")",
")",
"l",
".",
"append",
"(",
"''",
")",
"l",
".",
"append",
"(",
"v",
")",
"l",
".",
"append",
"(",
"'--'",
"+",
"boundary",
"+",
"'--'",
")",
"l",
".",
"append",
"(",
"''",
")",
"body",
"=",
"crlf",
".",
"join",
"(",
"l",
")",
"return",
"boundary",
",",
"body"
] | fields is a sequence of (name, value) elements for regular form fields.
files is a sequence of (name, filename, value) elements for data to be uploaded as files
Return (content_type, body) ready for httplib.HTTP instance | [
"fields",
"is",
"a",
"sequence",
"of",
"(",
"name",
"value",
")",
"elements",
"for",
"regular",
"form",
"fields",
".",
"files",
"is",
"a",
"sequence",
"of",
"(",
"name",
"filename",
"value",
")",
"elements",
"for",
"data",
"to",
"be",
"uploaded",
"as",
"files",
"Return",
"(",
"content_type",
"body",
")",
"ready",
"for",
"httplib",
".",
"HTTP",
"instance"
] | train | https://github.com/dustin/twitty-twister/blob/8524750ee73adb57bbe14ef0cfd8aa08e1e59fb3/twittytwister/twitter.py#L179-L204 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.