_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q262200 | calculate_concordance_probability_by_annotation | validation | def calculate_concordance_probability_by_annotation(graph, annotation, key, cutoff=None, permutations=None,
percentage=None,
use_ambiguous=False):
"""Returns the results of concordance analysis on each subgraph, stratified by the given annotation.
:param pybel.BELGraph graph: A BEL graph
:param str annotation: The annotation to group by.
:param str key: The node data dictionary key storing the logFC
:param float cutoff: The optional logFC cutoff for significance
:param int permutations: The number of random permutations to test. Defaults to 500
:param float percentage: The percentage of the graph's edges to maintain. Defaults to 0.9
:param bool use_ambiguous: Compare to ambiguous edges as well
:rtype: dict[str,tuple]
| python | {
"resource": ""
} |
q262201 | _get_drug_target_interactions | validation | def _get_drug_target_interactions(manager: Optional['bio2bel_drugbank.manager'] = None) -> Mapping[str, List[str]]:
"""Get a mapping from drugs to their list of | python | {
"resource": ""
} |
q262202 | multi_run_epicom | validation | def multi_run_epicom(graphs: Iterable[BELGraph], path: Union[None, str, TextIO]) -> None:
"""Run EpiCom analysis on many graphs."""
| python | {
"resource": ""
} |
q262203 | main | validation | def main():
"""Convert the Alzheimer's and Parkinson's disease NeuroMMSig excel sheets to BEL."""
logging.basicConfig(level=logging.INFO)
log.setLevel(logging.INFO)
bms_base = get_bms_base()
neurommsig_base = get_neurommsig_base()
neurommsig_excel_dir = os.path.join(neurommsig_base, 'resources', 'excels', 'neurommsig')
nift_values = get_nift_values()
log.info('Starting Alzheimers')
ad_path = os.path.join(neurommsig_excel_dir, 'alzheimers', 'alzheimers.xlsx')
ad_df = preprocess(ad_path)
with open(os.path.join(bms_base, 'aetionomy', 'alzheimers', 'neurommsigdb_ad.bel'), 'w') as ad_file:
| python | {
"resource": ""
} |
q262204 | remove_inconsistent_edges | validation | def remove_inconsistent_edges(graph: BELGraph) -> None:
"""Remove all edges between node pairs with inconsistent edges.
This is the all-or-nothing approach. It would be better to do more careful investigation of the evidences during
curation. | python | {
"resource": ""
} |
q262205 | get_walks_exhaustive | validation | def get_walks_exhaustive(graph, node, length):
"""Gets all walks under a given length starting at a given node
:param networkx.Graph graph: A graph
:param node: Starting node
:param int length: The length of walks to get
| python | {
"resource": ""
} |
q262206 | match_simple_metapath | validation | def match_simple_metapath(graph, node, simple_metapath):
"""Matches a simple metapath starting at the given node
:param pybel.BELGraph graph: A BEL graph
:param tuple node: A BEL node
:param list[str] simple_metapath: A list of BEL Functions
:return: An iterable over paths from the node | python | {
"resource": ""
} |
q262207 | build_database | validation | def build_database(manager: pybel.Manager, annotation_url: Optional[str] = None) -> None:
"""Build a database of scores for NeuroMMSig annotated graphs.
1. Get all networks that use the Subgraph annotation
2. run on each
"""
annotation_url = annotation_url or NEUROMMSIG_DEFAULT_URL
annotation = manager.get_namespace_by_url(annotation_url)
if annotation is None:
raise RuntimeError('no graphs in database with given annotation')
networks = get_networks_using_annotation(manager, annotation)
dtis = ...
for network in networks:
graph = network.as_bel()
scores = epicom_on_graph(graph, dtis)
for (drug_name, subgraph_name), score in scores.items():
drug_model = get_drug_model(manager, drug_name) | python | {
"resource": ""
} |
q262208 | calculate_average_scores_on_graph | validation | def calculate_average_scores_on_graph(
graph: BELGraph,
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
use_tqdm: bool = False,
):
"""Calculate the scores over all biological processes in the sub-graph.
As an implementation, it simply computes the sub-graphs then calls :func:`calculate_average_scores_on_subgraphs` as
described in that function's documentation.
:param graph: A BEL graph with heats already on the nodes
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
:param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'
:param default_score: The initial score for all nodes. This number can go up or down.
:param runs: The number of times to run the heat diffusion workflow. Defaults to 100.
:param use_tqdm: Should there be a progress bar for runners?
| python | {
"resource": ""
} |
q262209 | calculate_average_scores_on_subgraphs | validation | def calculate_average_scores_on_subgraphs(
subgraphs: Mapping[H, BELGraph],
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
use_tqdm: bool = False,
tqdm_kwargs: Optional[Mapping[str, Any]] = None,
) -> Mapping[H, Tuple[float, float, float, float, int, int]]:
"""Calculate the scores over precomputed candidate mechanisms.
:param subgraphs: A dictionary of keys to their corresponding subgraphs
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
:param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'
:param default_score: The initial score for all nodes. This number can go up or down.
:param runs: The number of times to run the heat diffusion workflow. Defaults to 100.
:param use_tqdm: Should there be a progress bar for runners?
:return: A dictionary of keys to results tuples
Example Usage:
>>> import pandas as pd
>>> from pybel_tools.generation import generate_bioprocess_mechanisms
>>> from pybel_tools.analysis.heat import calculate_average_scores_on_subgraphs
>>> # load graph and data
>>> graph = ...
>>> candidate_mechanisms = generate_bioprocess_mechanisms(graph)
>>> scores = calculate_average_scores_on_subgraphs(candidate_mechanisms)
>>> pd.DataFrame.from_items(scores.items(), orient='index', columns=RESULT_LABELS)
"""
results = {}
log.info('calculating results for %d candidate mechanisms using %d permutations', len(subgraphs), runs)
it = subgraphs.items()
if use_tqdm:
_tqdm_kwargs = dict(total=len(subgraphs), desc='Candidate mechanisms')
if tqdm_kwargs:
_tqdm_kwargs.update(tqdm_kwargs)
it = tqdm(it, **_tqdm_kwargs)
for node, subgraph in it: | python | {
"resource": ""
} |
q262210 | workflow | validation | def workflow(
graph: BELGraph,
node: BaseEntity,
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
minimum_nodes: int = 1,
) -> List['Runner']:
"""Generate candidate mechanisms and run the heat diffusion workflow.
:param graph: A BEL graph
:param node: The BEL node that is the focus of this analysis
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
:param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'
:param default_score: The initial score for all nodes. This number can go up or down.
:param runs: The number of times to run the heat diffusion workflow. Defaults to 100.
| python | {
"resource": ""
} |
q262211 | workflow_aggregate | validation | def workflow_aggregate(graph: BELGraph,
node: BaseEntity,
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
aggregator: Optional[Callable[[Iterable[float]], float]] = None,
) -> Optional[float]:
"""Get the average score over multiple runs.
This function is very simple, and can be copied to do more interesting statistics over the :class:`Runner`
instances. To iterate over the runners themselves, see :func:`workflow`
:param graph: A BEL graph
:param node: The BEL node that is the focus of this analysis
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
:param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'
:param default_score: The initial score for all nodes. This number can go up or down.
| python | {
"resource": ""
} |
q262212 | workflow_all | validation | def workflow_all(graph: BELGraph,
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
) -> Mapping[BaseEntity, List[Runner]]:
"""Run the heat diffusion workflow and get runners for every possible candidate mechanism
1. Get all biological processes
2. Get candidate mechanism induced two level back from each biological process
3. Heat diffusion workflow for each candidate mechanism for multiple runs
4. Return all runner results
:param graph: A BEL graph
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
:param tag: The key for the nodes' data dictionaries where the scores will be put. Defaults to 'score'
| python | {
"resource": ""
} |
q262213 | workflow_all_aggregate | validation | def workflow_all_aggregate(graph: BELGraph,
key: Optional[str] = None,
tag: Optional[str] = None,
default_score: Optional[float] = None,
runs: Optional[int] = None,
aggregator: Optional[Callable[[Iterable[float]], float]] = None,
):
"""Run the heat diffusion workflow to get average score for every possible candidate mechanism.
1. Get all biological processes
2. Get candidate mechanism induced two level back from each biological process
3. Heat diffusion workflow on each candidate mechanism for multiple runs
4. Report average scores for each candidate mechanism
:param graph: A BEL graph
:param key: The key in the node data dictionary representing the experimental data. Defaults to
| python | {
"resource": ""
} |
q262214 | calculate_average_score_by_annotation | validation | def calculate_average_score_by_annotation(
graph: BELGraph,
annotation: str,
key: Optional[str] = None,
runs: Optional[int] = None,
use_tqdm: bool = False,
) -> Mapping[str, float]:
"""For each sub-graph induced over the edges matching the annotation, calculate the average score
for all of the contained biological processes
Assumes you haven't done anything yet
1. Generates biological process upstream candidate mechanistic sub-graphs with
:func:`generate_bioprocess_mechanisms`
2. Calculates scores for each sub-graph with :func:`calculate_average_scores_on_sub-graphs`
3. Overlays data with pbt.integration.overlay_data
4. Calculates averages with pbt.selection.group_nodes.average_node_annotation
:param graph: A BEL graph
:param annotation: A BEL annotation
:param key: The key in the node data dictionary representing the experimental data. Defaults to
:data:`pybel_tools.constants.WEIGHT`.
| python | {
"resource": ""
} |
q262215 | Runner.iter_leaves | validation | def iter_leaves(self) -> Iterable[BaseEntity]:
"""Return an iterable over all nodes that are leaves.
A node is a leaf if either:
- it doesn't have any predecessors, OR
- all of its predecessors have a score in their data dictionaries
"""
for node in self.graph:
| python | {
"resource": ""
} |
q262216 | Runner.unscored_nodes_iter | validation | def unscored_nodes_iter(self) -> BaseEntity:
"""Iterate over all nodes without a score."""
| python | {
"resource": ""
} |
q262217 | Runner.remove_random_edge_until_has_leaves | validation | def remove_random_edge_until_has_leaves(self) -> None:
"""Remove random edges until there is at least one leaf node."""
while True:
| python | {
"resource": ""
} |
q262218 | Runner.score_leaves | validation | def score_leaves(self) -> Set[BaseEntity]:
"""Calculate the score for all leaves.
:return: The set of leaf nodes that were scored
"""
leaves = set(self.iter_leaves())
if not leaves:
log.warning('no leaves.')
| python | {
"resource": ""
} |
q262219 | Runner.run_with_graph_transformation | validation | def run_with_graph_transformation(self) -> Iterable[BELGraph]:
"""Calculate scores for all leaves until there are none, removes edges until there are, and repeats until
all nodes have been scored. Also, yields the current graph at every step so you can make a cool animation
| python | {
"resource": ""
} |
q262220 | Runner.done_chomping | validation | def done_chomping(self) -> bool:
"""Determines if the algorithm is complete by checking if the target node of this analysis has been scored
yet. Because the algorithm removes edges when it gets stuck until it is un-stuck, it is always guaranteed to
| python | {
"resource": ""
} |
q262221 | Runner.get_final_score | validation | def get_final_score(self) -> float:
"""Return the final score for the target node.
:return: The final score for the target node
"""
if not self.done_chomping():
raise | python | {
"resource": ""
} |
q262222 | Runner.calculate_score | validation | def calculate_score(self, node: BaseEntity) -> float:
"""Calculate the new score of the given node."""
score = (
self.graph.nodes[node][self.tag]
if self.tag in self.graph.nodes[node] else
self.default_score
)
for predecessor, _, d in self.graph.in_edges(node, data=True):
| python | {
"resource": ""
} |
q262223 | microcanonical_statistics_dtype | validation | def microcanonical_statistics_dtype(spanning_cluster=True):
"""
Return the numpy structured array data type for sample states
Helper function
Parameters
----------
spanning_cluster : bool, optional
Whether to detect a spanning cluster or not.
Defaults to ``True``.
Returns
-------
ret : list of pairs of str
A list of tuples of field names and | python | {
"resource": ""
} |
q262224 | canonical_statistics_dtype | validation | def canonical_statistics_dtype(spanning_cluster=True):
"""
The NumPy Structured Array type for canonical statistics
Helper function
Parameters
----------
spanning_cluster : bool, optional
Whether to detect a spanning cluster or not.
Defaults to ``True``.
Returns
-------
ret : list of pairs of str
A list of tuples of field names and data types to be used as ``dtype``
argument in numpy ndarray constructors
See Also
| python | {
"resource": ""
} |
q262225 | bond_canonical_statistics | validation | def bond_canonical_statistics(
microcanonical_statistics,
convolution_factors,
**kwargs
):
"""
canonical cluster statistics for a single run and a single probability
Parameters
----------
microcanonical_statistics : ndarray
Return value of `bond_microcanonical_statistics`
convolution_factors : 1-D array_like
The coefficients of the convolution for the given probabilty ``p``
and for each occupation number ``n``.
Returns
-------
ret : ndarray of size ``1``
Structured array with dtype as returned by
`canonical_statistics_dtype`
ret['percolation_probability'] : ndarray of float
The "percolation probability" of this run at the value of ``p``.
Only exists if `microcanonical_statistics` argument has the
``has_spanning_cluster`` field.
ret['max_cluster_size'] : ndarray of int
Weighted size of the largest cluster (absolute number of sites)
ret['moments'] : 1-D :py:class:`numpy.ndarray` of float
Array of size ``5``.
The ``k``-th entry is the weighted ``k``-th raw moment of the
(absolute) cluster size distribution, with ``k`` ranging from ``0`` to
``4``.
See Also
--------
bond_microcanonical_statistics
canonical_statistics_dtype
"""
# initialize return array
spanning_cluster = (
| python | {
"resource": ""
} |
q262226 | canonical_averages_dtype | validation | def canonical_averages_dtype(spanning_cluster=True):
"""
The NumPy Structured Array type for canonical averages over several
runs
Helper function
Parameters
----------
spanning_cluster : bool, optional
Whether to detect a spanning cluster or not.
Defaults to ``True``.
Returns
-------
ret : list of pairs of str
A list of tuples of field names and data types to be used as ``dtype``
argument in numpy ndarray constructors
See Also
--------
http://docs.scipy.org/doc/numpy/user/basics.rec.html
canonical_statistics_dtype
finalized_canonical_averages_dtype
"""
fields = list()
fields.extend([
('number_of_runs', 'uint32'),
])
if spanning_cluster:
| python | {
"resource": ""
} |
q262227 | bond_initialize_canonical_averages | validation | def bond_initialize_canonical_averages(
canonical_statistics, **kwargs
):
"""
Initialize the canonical averages from a single-run cluster statistics
Parameters
----------
canonical_statistics : 1-D structured ndarray
Typically contains the canonical statistics for a range of values
of the occupation probability ``p``.
The dtype is the result of `canonical_statistics_dtype`.
Returns
-------
ret : structured ndarray
The dype is the result of `canonical_averages_dtype`.
ret['number_of_runs'] : 1-D ndarray of int
Equals ``1`` (initial run).
ret['percolation_probability_mean'] : 1-D array of float
Equals ``canonical_statistics['percolation_probability']``
(if ``percolation_probability`` is present)
ret['percolation_probability_m2'] : 1-D array of float
Each entry is ``0.0``
ret['max_cluster_size_mean'] : 1-D array of float
Equals ``canonical_statistics['max_cluster_size']``
ret['max_cluster_size_m2'] : 1-D array of float
Each entry is ``0.0``
ret['moments_mean'] : 2-D array of float
Equals ``canonical_statistics['moments']``
ret['moments_m2'] : 2-D array of float
Each entry is ``0.0``
See Also
--------
canonical_averages_dtype
bond_canonical_statistics
"""
# initialize return array
spanning_cluster = (
'percolation_probability' in canonical_statistics.dtype.names
)
# array should have | python | {
"resource": ""
} |
q262228 | bond_reduce | validation | def bond_reduce(row_a, row_b):
"""
Reduce the canonical averages over several runs
This is a "true" reducer.
It is associative and commutative.
This is a wrapper around `simoa.stats.online_variance`.
Parameters
----------
row_a, row_b : structured ndarrays
Output of this function, or initial input from
`bond_initialize_canonical_averages`
Returns
-------
ret : structured ndarray
Array is of dtype as returned by `canonical_averages_dtype`
See Also
--------
bond_initialize_canonical_averages
canonical_averages_dtype
simoa.stats.online_variance
"""
spanning_cluster = (
'percolation_probability_mean' in row_a.dtype.names and
'percolation_probability_mean' in row_b.dtype.names and
'percolation_probability_m2' in row_a.dtype.names and
'percolation_probability_m2' in row_b.dtype.names
)
# initialize return array
ret = np.empty_like(row_a)
def _reducer(key, transpose=False):
mean_key = '{}_mean'.format(key)
m2_key = '{}_m2'.format(key)
res = simoa.stats.online_variance(*[
(
row['number_of_runs'],
row[mean_key].T if | python | {
"resource": ""
} |
q262229 | finalized_canonical_averages_dtype | validation | def finalized_canonical_averages_dtype(spanning_cluster=True):
"""
The NumPy Structured Array type for finalized canonical averages over
several runs
Helper function
Parameters
----------
spanning_cluster : bool, optional
Whether to detect a spanning cluster or not.
Defaults to ``True``.
Returns
-------
ret : list of pairs of str
A list of tuples of field names and data types to be used as ``dtype``
argument in numpy ndarray constructors
See Also
--------
http://docs.scipy.org/doc/numpy/user/basics.rec.html
canonical_averages_dtype
"""
fields = list()
fields.extend([
('number_of_runs', 'uint32'),
('p', 'float64'),
('alpha', 'float64'),
])
if spanning_cluster:
| python | {
"resource": ""
} |
q262230 | finalize_canonical_averages | validation | def finalize_canonical_averages(
number_of_nodes, ps, canonical_averages, alpha,
):
"""
Finalize canonical averages
"""
spanning_cluster = (
(
'percolation_probability_mean' in
canonical_averages.dtype.names
) and
'percolation_probability_m2' in canonical_averages.dtype.names
)
# append values of p as an additional field
ret = np.empty_like(
canonical_averages,
dtype=finalized_canonical_averages_dtype(
spanning_cluster=spanning_cluster
),
)
n = canonical_averages['number_of_runs']
sqrt_n = np.sqrt(canonical_averages['number_of_runs'])
ret['number_of_runs'] = n
ret['p'] = ps
ret['alpha'] = alpha
def _transform(
original_key, final_key=None, normalize=False, transpose=False,
):
if final_key is None:
final_key = original_key
keys_mean = [
'{}_mean'.format(key)
for key in [original_key, final_key]
| python | {
"resource": ""
} |
q262231 | compare | validation | def compare(graph: BELGraph, annotation: str = 'Subgraph') -> Mapping[str, Mapping[str, float]]:
"""Compare generated mechanisms to actual ones.
1. Generates candidate mechanisms for each biological process
2. Gets sub-graphs for all NeuroMMSig signatures
3. Make tanimoto similarity comparison for all sets
:return: A dictionary table comparing the canonical subgraphs to generated ones
"""
canonical_mechanisms = get_subgraphs_by_annotation(graph, | python | {
"resource": ""
} |
q262232 | summarize_node_filter | validation | def summarize_node_filter(graph: BELGraph, node_filters: NodePredicates) -> None:
"""Print a summary of the number of nodes passing a given set of filters.
| python | {
"resource": ""
} |
q262233 | node_inclusion_filter_builder | validation | def node_inclusion_filter_builder(nodes: Iterable[BaseEntity]) -> NodePredicate:
"""Build a filter that only passes on nodes in the given list.
:param nodes: An iterable of BEL nodes
"""
node_set = set(nodes)
def inclusion_filter(_: BELGraph, node: BaseEntity) -> bool:
"""Pass only for a node that is in the enclosed node | python | {
"resource": ""
} |
q262234 | node_exclusion_filter_builder | validation | def node_exclusion_filter_builder(nodes: Iterable[BaseEntity]) -> NodePredicate:
"""Build a filter that fails on nodes in the given list."""
node_set = set(nodes)
def exclusion_filter(_: BELGraph, node: | python | {
"resource": ""
} |
q262235 | function_namespace_inclusion_builder | validation | def function_namespace_inclusion_builder(func: str, namespace: Strings) -> NodePredicate:
"""Build a filter function for matching the given BEL function with the given namespace or namespaces.
:param func: A BEL function
:param namespace: The namespace to search by
"""
if isinstance(namespace, str):
def function_namespaces_filter(_: BELGraph, node: BaseEntity) -> bool:
"""Pass only for nodes that have the enclosed function and enclosed namespace."""
if func != node[FUNCTION]:
return False
return NAMESPACE in node and node[NAMESPACE] == namespace
elif isinstance(namespace, Iterable):
| python | {
"resource": ""
} |
q262236 | data_contains_key_builder | validation | def data_contains_key_builder(key: str) -> NodePredicate: # noqa: D202
"""Build a filter that passes only on nodes that have the given key in their data dictionary.
:param key: A key for the node's data dictionary
"""
def data_contains_key(_: BELGraph, node: BaseEntity) -> bool:
"""Pass only for a node that contains the enclosed key in | python | {
"resource": ""
} |
q262237 | variants_of | validation | def variants_of(
graph: BELGraph,
node: Protein,
modifications: Optional[Set[str]] = None,
) -> Set[Protein]:
"""Returns all variants of the given node."""
if modifications:
return _get_filtered_variants_of(graph, node, modifications)
return {
v
for | python | {
"resource": ""
} |
q262238 | get_variants_to_controllers | validation | def get_variants_to_controllers(
graph: BELGraph,
node: Protein,
modifications: Optional[Set[str]] = None,
) -> Mapping[Protein, Set[Protein]]:
"""Get a mapping from variants of the given node to all of its upstream controllers."""
rv = defaultdict(set)
| python | {
"resource": ""
} |
q262239 | group_dict_set | validation | def group_dict_set(iterator: Iterable[Tuple[A, B]]) -> Mapping[A, Set[B]]:
"""Make a dict that accumulates the | python | {
"resource": ""
} |
q262240 | count_unique_relations | validation | def count_unique_relations(graph: BELGraph) -> Counter:
"""Return a histogram of the different types of relations present in a graph.
Note: this operation only counts each type of edge once | python | {
"resource": ""
} |
q262241 | count_annotation_values | validation | def count_annotation_values(graph: BELGraph, annotation: str) -> Counter:
"""Count in how many edges each annotation appears in a graph
:param graph: A BEL graph
:param annotation: The annotation | python | {
"resource": ""
} |
q262242 | count_annotation_values_filtered | validation | def count_annotation_values_filtered(graph: BELGraph,
annotation: str,
source_predicate: Optional[NodePredicate] = None,
target_predicate: Optional[NodePredicate] = None,
) -> Counter:
"""Count in how many edges each annotation appears in a graph, but filter out source nodes and target nodes.
See :func:`pybel_tools.utils.keep_node` for a basic filter.
:param graph: A BEL graph
:param annotation: The annotation to count
:param source_predicate: A predicate (graph, node) -> bool for keeping source nodes
:param target_predicate: A predicate (graph, node) -> bool for keeping target nodes
:return: A Counter from {annotation value: frequency}
"""
if source_predicate and target_predicate:
return Counter(
data[ANNOTATIONS][annotation]
for u, v, data in graph.edges(data=True)
if edge_has_annotation(data, annotation) and source_predicate(graph, u) and target_predicate(graph, v)
)
elif source_predicate:
return Counter(
data[ANNOTATIONS][annotation]
for u, | python | {
"resource": ""
} |
q262243 | pair_is_consistent | validation | def pair_is_consistent(graph: BELGraph, u: BaseEntity, v: BaseEntity) -> Optional[str]:
"""Return if the edges between the given nodes are consistent, meaning they all have the same relation.
:return: If the edges aren't consistent, return false, otherwise return | python | {
"resource": ""
} |
q262244 | infer_missing_two_way_edges | validation | def infer_missing_two_way_edges(graph):
"""Add edges to the graph when a two way edge exists, and the opposite direction doesn't exist.
Use: two way edges from BEL definition and/or axiomatic | python | {
"resource": ""
} |
q262245 | infer_missing_backwards_edge | validation | def infer_missing_backwards_edge(graph, u, v, k):
"""Add the same edge, but in the opposite direction if not already present.
:type graph: pybel.BELGraph
:type u: tuple
:type v: tuple
:type k: int
"""
if u in graph[v]:
| python | {
"resource": ""
} |
q262246 | enrich_internal_unqualified_edges | validation | def enrich_internal_unqualified_edges(graph, subgraph):
"""Add the missing unqualified edges between entities in the subgraph that are contained within the full graph.
:param pybel.BELGraph graph: The full BEL graph
:param pybel.BELGraph subgraph: The query BEL subgraph
"""
for u, v in itt.combinations(subgraph, 2):
| python | {
"resource": ""
} |
q262247 | boilerplate | validation | def boilerplate(name, contact, description, pmids, version, copyright, authors, licenses, disclaimer, output):
"""Build a template BEL document with the given PubMed identifiers."""
from .document_utils import write_boilerplate
write_boilerplate(
name=name,
version=version,
description=description,
| python | {
"resource": ""
} |
q262248 | get_pmids | validation | def get_pmids(graph: BELGraph, output: TextIO):
"""Output PubMed identifiers from a graph to a stream."""
| python | {
"resource": ""
} |
q262249 | Table.getrowcount | validation | def getrowcount(self, window_name, object_name):
"""
Get count of rows in table object.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@return: Number of rows.
@rtype: integer
"""
| python | {
"resource": ""
} |
q262250 | Table.multiselect | validation | def multiselect(self, window_name, object_name, row_text_list, partial_match=False):
"""
Select multiple row
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_text_list: Row list with matching text to select
@type row_text: string
@return: 1 on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
raise LdtpServerException(u"Object %s state disabled" % object_name)
object_handle.activate()
selected = False
try:
window = self._get_front_most_window()
except (IndexError,):
| python | {
"resource": ""
} |
q262251 | Table.selectrowpartialmatch | validation | def selectrowpartialmatch(self, window_name, object_name, row_text):
"""
Select row partial match
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_text: Row text to select
@type row_text: string
@return: 1 on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
raise LdtpServerException(u"Object %s state | python | {
"resource": ""
} |
q262252 | Table.selectrowindex | validation | def selectrowindex(self, window_name, object_name, row_index):
"""
Select row index
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_index: Row index to select
@type row_index: integer
@return: 1 on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
| python | {
"resource": ""
} |
q262253 | Table.selectlastrow | validation | def selectlastrow(self, window_name, object_name):
"""
Select last row
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
| python | {
"resource": ""
} |
q262254 | Table.getcellvalue | validation | def getcellvalue(self, window_name, object_name, row_index, column=0):
"""
Get cell value
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_index: Row index to get
@type row_index: integer
@param column: Column index to get, default value 0
@type column: integer
@return: cell value on success.
@rtype: string
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
| python | {
"resource": ""
} |
q262255 | Table.gettablerowindex | validation | def gettablerowindex(self, window_name, object_name, row_text):
"""
Get table row index matching given text
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_text: Row text to select
@type row_text: string
@return: row index matching the text on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name) | python | {
"resource": ""
} |
q262256 | Table.verifypartialtablecell | validation | def verifypartialtablecell(self, window_name, object_name, row_index,
column_index, row_text):
"""
Verify partial table cell value
@param window_name: Window name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to type in, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param row_index: Row index to get
@type row_index: integer
@param column_index: Column index to get, default value 0
@type column_index: integer
| python | {
"resource": ""
} |
q262257 | Core.getapplist | validation | def getapplist(self):
"""
Get all accessibility application name that are currently running
@return: list of appliction name of string type on success.
@rtype: list
"""
app_list = []
# Update apps list, before parsing the list
self._update_apps()
for gui in self._running_apps:
name = gui.localizedName()
# default type was objc.pyobjc_unicode
# convert to Unicode, else exception is thrown
# TypeError: "cannot marshal <type 'objc.pyobjc_unicode'> objects"
| python | {
"resource": ""
} |
q262258 | Core.startprocessmonitor | validation | def startprocessmonitor(self, process_name, interval=2):
"""
Start memory and CPU monitoring, with the time interval between
each process scan
@param process_name: Process name, ex: firefox-bin.
@type process_name: string
@param interval: Time interval between each process scan
@type interval: double
@return: 1 on success
@rtype: integer
"""
if process_name in self._process_stats:
# Stop previously running instance
# At any point, only one process name can be | python | {
"resource": ""
} |
q262259 | Core.stopprocessmonitor | validation | def stopprocessmonitor(self, process_name):
"""
Stop memory and CPU monitoring
@param process_name: Process name, ex: firefox-bin.
@type process_name: string
@return: 1 on success
@rtype: integer
"""
| python | {
"resource": ""
} |
q262260 | Core.getcpustat | validation | def getcpustat(self, process_name):
"""
get CPU stat for the give process name
@param process_name: Process name, ex: firefox-bin.
@type process_name: string
@return: cpu stat list on success, else empty list
If same process name, running multiple instance,
get the stat of all the process CPU usage
@rtype: list
"""
# Create an instance of process stat
_stat_inst = ProcessStats(process_name)
| python | {
"resource": ""
} |
q262261 | Core.getmemorystat | validation | def getmemorystat(self, process_name):
"""
get memory stat
@param process_name: Process name, ex: firefox-bin.
@type process_name: string
@return: memory stat list on success, else empty list
If same process name, running multiple instance,
get the stat of all the process memory usage
@rtype: list
"""
# Create an instance of process stat
_stat_inst = ProcessStats(process_name)
_stat_list = []
for p in _stat_inst.get_cpu_memory_stat():
| python | {
"resource": ""
} |
q262262 | Core.getobjectlist | validation | def getobjectlist(self, window_name):
"""
Get list of items in given GUI.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@return: list of items in LDTP naming convention.
@rtype: list
"""
try:
window_handle, name, app = self._get_window_handle(window_name, True) | python | {
"resource": ""
} |
q262263 | Core.getobjectinfo | validation | def getobjectinfo(self, window_name, object_name):
"""
Get object properties.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: list of properties
@rtype: list
"""
try:
obj_info = self._get_object_map(window_name, object_name,
| python | {
"resource": ""
} |
q262264 | Core.getobjectproperty | validation | def getobjectproperty(self, window_name, object_name, prop):
"""
Get object property value.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param prop: property name.
@type prop: string
@return: property
@rtype: string
"""
try:
obj_info = self._get_object_map(window_name, object_name,
wait_for_object=False)
except atomac._a11y.ErrorInvalidUIElement:
# During the test, when the window closed and reopened
# ErrorInvalidUIElement exception will be thrown
self._windows = {}
# Call the method again, after updating apps
obj_info = self._get_object_map(window_name, object_name,
| python | {
"resource": ""
} |
q262265 | Core.getchild | validation | def getchild(self, window_name, child_name='', role='', parent=''):
"""
Gets the list of object available in the window, which matches
component name or role name or both.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param child_name: Child name to search for.
@type child_name: string
@param role: role name to search for, or an empty string for wildcard.
@type role: string
@param parent: parent name to search for, or an empty string for wildcard.
@type role: string
@return: list of matched children names
@rtype: list
"""
matches = []
if role:
role = re.sub(' ', '_', role)
self._windows = {}
if parent and (child_name or role):
_window_handle, _window_name = \
self._get_window_handle(window_name)[0:2]
if not _window_handle:
raise LdtpServerException('Unable to find window "%s"' % \
window_name)
appmap = self._get_appmap(_window_handle, _window_name)
obj = self._get_object_map(window_name, parent)
def _get_all_children_under_obj(obj, child_list):
if role and obj['class'] == role:
child_list.append(obj['label'])
elif child_name and self._match_name_to_appmap(child_name, obj):
child_list.append(obj['label'])
if obj:
children = obj['children']
if not children:
| python | {
"resource": ""
} |
q262266 | Core.launchapp | validation | def launchapp(self, cmd, args=[], delay=0, env=1, lang="C"):
"""
Launch application.
@param cmd: Command line string to execute.
@type cmd: string
@param args: Arguments to the application
@type args: list
@param delay: Delay after the application is launched
@type delay: int
@param env: GNOME accessibility environment to be set or not
@type env: int
@param lang: Application language to be used
@type lang: string
@return: 1 on success
@rtype: integer
@raise LdtpServerException: When command fails
"""
try:
| python | {
"resource": ""
} |
q262267 | Core.activatewindow | validation | def activatewindow(self, window_name):
"""
Activate window.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@return: 1 on success.
| python | {
"resource": ""
} |
q262268 | Core.click | validation | def click(self, window_name, object_name):
"""
Click item.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
raise LdtpServerException(u"Object %s state disabled" % object_name)
size = self._getobjectsize(object_handle)
self._grabfocus(object_handle)
self.wait(0.5)
| python | {
"resource": ""
} |
q262269 | Core.getallstates | validation | def getallstates(self, window_name, object_name):
"""
Get all states of given object
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: list of string on success.
@rtype: list
"""
| python | {
"resource": ""
} |
q262270 | Core.getobjectsize | validation | def getobjectsize(self, window_name, object_name=None):
"""
Get object size
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@return: x, y, width, height on success.
@rtype: list
"""
| python | {
"resource": ""
} |
q262271 | Core.grabfocus | validation | def grabfocus(self, window_name, object_name=None):
"""
Grab focus.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
| python | {
"resource": ""
} |
q262272 | Core.waittillguiexist | validation | def waittillguiexist(self, window_name, object_name='',
guiTimeOut=30, state=''):
"""
Wait till a window or component exists.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param guiTimeOut: Wait timeout in seconds
@type guiTimeOut: integer
@param state: Object state used only when object_name is provided.
@type object_name: string
| python | {
"resource": ""
} |
q262273 | Core.waittillguinotexist | validation | def waittillguinotexist(self, window_name, object_name='', guiTimeOut=30):
"""
Wait till a window does not exist.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@param guiTimeOut: Wait timeout in seconds
@type guiTimeOut: integer
@return: 1 if GUI has gone away, 0 if not.
@rtype: integer
| python | {
"resource": ""
} |
q262274 | Core.stateenabled | validation | def stateenabled(self, window_name, object_name):
"""
Check whether an object state is enabled or not
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success 0 on failure.
@rtype: integer
"""
| python | {
"resource": ""
} |
q262275 | Core.check | validation | def check(self, window_name, object_name):
"""
Check item.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
# FIXME: Check for object type
object_handle = self._get_object_handle(window_name, object_name)
if not object_handle.AXEnabled:
raise LdtpServerException(u"Object %s state disabled" % object_name)
if object_handle.AXValue == 1:
# Already checked | python | {
"resource": ""
} |
q262276 | Core.verifycheck | validation | def verifycheck(self, window_name, object_name):
"""
Verify check item.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type object_name: string
@return: 1 on success 0 on failure.
@rtype: integer
"""
try:
| python | {
"resource": ""
} |
q262277 | Core.getaccesskey | validation | def getaccesskey(self, window_name, object_name):
"""
Get access key of given object
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@return: access key in string format on success, else LdtpExecutionError on failure.
@rtype: string
"""
# Used http://www.danrodney.com/mac/ as reference for
# mapping keys with specific control
# In Mac noticed (in accessibility inspector) only menu had access keys
# so, get the menu_handle of given object and
# return the access key
menu_handle = self._get_menu_handle(window_name, object_name)
key = menu_handle.AXMenuItemCmdChar
modifiers = menu_handle.AXMenuItemCmdModifiers
glpyh = menu_handle.AXMenuItemCmdGlyph
virtual_key = menu_handle.AXMenuItemCmdVirtualKey
modifiers_type = ""
if modifiers == 0:
modifiers_type = "<command>"
elif modifiers == 1:
modifiers_type = "<shift><command>"
elif modifiers == 2:
modifiers_type = "<option><command>"
elif modifiers == 3:
modifiers_type = "<option><shift><command>"
elif modifiers == 4:
modifiers_type = "<ctrl><command>"
elif modifiers == 6:
modifiers_type = "<ctrl><option><command>"
# Scroll up
if virtual_key == 115 and glpyh == 102:
modifiers = "<option>"
key = "<cursor_left>"
# Scroll down
elif virtual_key == 119 and glpyh == 105:
modifiers = "<option>"
key = "<right>"
# Page up
elif virtual_key == 116 and glpyh == 98:
modifiers = "<option>"
key = "<up>"
# Page down
| python | {
"resource": ""
} |
q262278 | Clipboard.clearContents | validation | def clearContents(cls):
"""Clear contents of general pasteboard.
Future enhancement can include specifying which clipboard to clear
Returns: True on success; caller should expect to catch exceptions,
probably from AppKit (ValueError)
"""
| python | {
"resource": ""
} |
q262279 | Clipboard.isEmpty | validation | def isEmpty(cls, datatype=None):
"""Method to test if the general pasteboard is empty or not with respect
to the type of object you want.
Parameters: datatype (defaults to strings)
Returns: Boolean True (empty) / False (has contents); Raises
exception (passes any raised up)
"""
if not datatype:
datatype = AppKit.NSString
if not isinstance(datatype, types.ListType):
datatype = [datatype]
pp = pprint.PrettyPrinter()
logging.debug('Desired datatypes: %s' % pp.pformat(datatype))
opt_dict = {}
logging.debug('Results filter is: %s' % pp.pformat(opt_dict))
try:
log_msg = 'Request to verify pasteboard is empty'
logging.debug(log_msg)
| python | {
"resource": ""
} |
q262280 | Utils._ldtpize_accessible | validation | def _ldtpize_accessible(self, acc):
"""
Get LDTP format accessibile name
@param acc: Accessible handle
@type acc: object
@return: object type, stripped object name (associated / direct),
associated label
@rtype: tuple
"""
actual_role = self._get_role(acc)
label = self._get_title(acc)
if re.match("AXWindow", actual_role, re.M | re.U | re.L):
| python | {
"resource": ""
} |
q262281 | Utils._glob_match | validation | def _glob_match(self, pattern, string):
"""
Match given string, by escaping regex characters
"""
# regex flags Multi-line, Unicode, Locale
| python | {
"resource": ""
} |
q262282 | Menu.doesmenuitemexist | validation | def doesmenuitemexist(self, window_name, object_name):
"""
Check a menu item exist.
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@param strict_hierarchy: Mandate menu hierarchy if set to True
@type object_name: boolean
@return: 1 on success.
| python | {
"resource": ""
} |
q262283 | Menu.menuitemenabled | validation | def menuitemenabled(self, window_name, object_name):
"""
Verify a menu item is enabled
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
try: | python | {
"resource": ""
} |
q262284 | Menu.verifymenucheck | validation | def verifymenucheck(self, window_name, object_name):
"""
Verify a menu item is checked
@param window_name: Window name to look for, either full name,
LDTP's name convention, or a Unix glob.
@type window_name: string
@param object_name: Object name to look for, either full name,
LDTP's name convention, or a Unix glob. Or menu heirarchy
@type object_name: string
@return: 1 on success.
@rtype: integer
"""
try:
menu_handle = | python | {
"resource": ""
} |
q262285 | BaseAXUIElement._getRunningApps | validation | def _getRunningApps(cls):
"""Get a list of the running applications."""
def runLoopAndExit():
AppHelper.stopEventLoop()
AppHelper.callLater(1, runLoopAndExit)
AppHelper.runConsoleEventLoop()
| python | {
"resource": ""
} |
q262286 | BaseAXUIElement.getFrontmostApp | validation | def getFrontmostApp(cls):
"""Get the current frontmost application.
Raise a ValueError exception if no GUI applications are found.
"""
# Refresh the runningApplications list
apps = cls._getRunningApps()
for app in apps:
pid = app.processIdentifier()
ref = cls.getAppRefByPid(pid)
try:
if ref.AXFrontmost:
return ref
except (_a11y.ErrorUnsupported,
_a11y.ErrorCannotComplete,
| python | {
"resource": ""
} |
q262287 | BaseAXUIElement.getAnyAppWithWindow | validation | def getAnyAppWithWindow(cls):
"""Get a random app that has windows.
Raise a ValueError exception if no GUI applications are found.
"""
# Refresh the runningApplications list
apps = cls._getRunningApps()
for app in apps:
| python | {
"resource": ""
} |
q262288 | BaseAXUIElement.launchAppByBundleId | validation | def launchAppByBundleId(bundleID):
"""Launch the application with the specified bundle ID"""
# NSWorkspaceLaunchAllowingClassicStartup does nothing on any
# modern system that doesn't have the classic environment installed.
# Encountered a bug when passing 0 for no options on 10.6 PyObjC.
ws = AppKit.NSWorkspace.sharedWorkspace()
| python | {
"resource": ""
} |
q262289 | BaseAXUIElement.launchAppByBundlePath | validation | def launchAppByBundlePath(bundlePath, arguments=None):
"""Launch app with a given bundle path.
Return True if succeed.
"""
if arguments is None:
arguments = []
bundleUrl = NSURL.fileURLWithPath_(bundlePath)
workspace = AppKit.NSWorkspace.sharedWorkspace()
arguments_strings = list(map(lambda a: NSString.stringWithString_(str(a)),
| python | {
"resource": ""
} |
q262290 | BaseAXUIElement.terminateAppByBundleId | validation | def terminateAppByBundleId(bundleID):
"""Terminate app with a given bundle ID.
Requires 10.6.
Return True if succeed.
"""
ra = AppKit.NSRunningApplication
| python | {
"resource": ""
} |
q262291 | BaseAXUIElement._queueEvent | validation | def _queueEvent(self, event, args):
"""Private method to queue events to run.
Each event in queue is a tuple (event call, args to event call).
"""
if not hasattr(self, 'eventList'):
| python | {
"resource": ""
} |
q262292 | BaseAXUIElement._addKeyToQueue | validation | def _addKeyToQueue(self, keychr, modFlags=0, globally=False):
"""Add keypress to queue.
Parameters: key character or constant referring to a non-alpha-numeric
key (e.g. RETURN or TAB)
modifiers
global or app specific
Returns: None or raise ValueError exception.
"""
# Awkward, but makes modifier-key-only combinations possible
# (since sendKeyWithModifiers() calls this)
if not keychr:
return
if not hasattr(self, 'keyboard'):
self.keyboard = AXKeyboard.loadKeyboard()
if keychr in self.keyboard['upperSymbols'] and not modFlags:
self._sendKeyWithModifiers(keychr,
[AXKeyCodeConstants.SHIFT],
globally)
return
if keychr.isupper() and not modFlags:
self._sendKeyWithModifiers(
keychr.lower(),
[AXKeyCodeConstants.SHIFT],
globally
)
return
if keychr not in self.keyboard:
self._clearEventQueue()
raise ValueError('Key %s not found in keyboard layout' % keychr)
# Press the key
keyDown = Quartz.CGEventCreateKeyboardEvent(None,
self.keyboard[keychr],
True)
# Release the key
keyUp = Quartz.CGEventCreateKeyboardEvent(None,
self.keyboard[keychr],
| python | {
"resource": ""
} |
q262293 | BaseAXUIElement._sendKey | validation | def _sendKey(self, keychr, modFlags=0, globally=False):
"""Send one character with no modifiers.
Parameters: key character or constant referring to a non-alpha-numeric
key (e.g. RETURN or TAB)
modifier flags,
global or app specific
Returns: None or raise ValueError exception
"""
escapedChrs = {
'\n': AXKeyCodeConstants.RETURN,
'\r': AXKeyCodeConstants.RETURN,
| python | {
"resource": ""
} |
q262294 | BaseAXUIElement._isSingleCharacter | validation | def _isSingleCharacter(keychr):
"""Check whether given keyboard character is a single character.
Parameters: key character which will be checked.
Returns: True when given key character is a single character.
"""
if not keychr:
return False
# Regular character case.
if len(keychr) == 1:
return | python | {
"resource": ""
} |
q262295 | BaseAXUIElement._sendKeyWithModifiers | validation | def _sendKeyWithModifiers(self, keychr, modifiers, globally=False):
"""Send one character with the given modifiers pressed.
Parameters: key character, list of modifiers, global or app specific
Returns: None or raise ValueError exception
"""
if not self._isSingleCharacter(keychr):
raise ValueError('Please provide only one character to send')
if not hasattr(self, 'keyboard'):
| python | {
"resource": ""
} |
q262296 | BaseAXUIElement._queueMouseButton | validation | def _queueMouseButton(self, coord, mouseButton, modFlags, clickCount=1,
dest_coord=None):
"""Private method to handle generic mouse button clicking.
Parameters: coord (x, y) to click, mouseButton (e.g.,
kCGMouseButtonLeft), modFlags set (int)
Optional: clickCount (default 1; set to 2 for double-click; 3 for
triple-click on host)
Returns: None
"""
# For now allow only left and right mouse buttons:
mouseButtons = {
Quartz.kCGMouseButtonLeft: 'LeftMouse',
Quartz.kCGMouseButtonRight: 'RightMouse',
}
if mouseButton not in mouseButtons:
raise ValueError('Mouse button given not recognized')
eventButtonDown = getattr(Quartz,
'kCGEvent%sDown' % mouseButtons[mouseButton])
eventButtonUp = getattr(Quartz,
'kCGEvent%sUp' % mouseButtons[mouseButton])
eventButtonDragged = getattr(Quartz,
'kCGEvent%sDragged' % mouseButtons[
mouseButton])
# Press the button
buttonDown = Quartz.CGEventCreateMouseEvent(None,
eventButtonDown,
coord,
mouseButton)
| python | {
"resource": ""
} |
q262297 | BaseAXUIElement._leftMouseDragged | validation | def _leftMouseDragged(self, stopCoord, strCoord, speed):
"""Private method to handle generic mouse left button dragging and
dropping.
Parameters: stopCoord(x,y) drop point
Optional: strCoord (x, y) drag point, default (0,0) get current
mouse position
speed (int) 1 to unlimit, simulate mouse moving
action from some special requirement
Returns: None
"""
# To direct output to the correct application need the PSN:
appPid = self._getPid()
# Get current position as start point if strCoord not given
if strCoord == (0, 0):
loc = AppKit.NSEvent.mouseLocation()
strCoord = (loc.x, Quartz.CGDisplayPixelsHigh(0) - loc.y)
# To direct output to the correct application need the PSN:
appPid = self._getPid()
# Press left button down
pressLeftButton = Quartz.CGEventCreateMouseEvent(
None,
Quartz.kCGEventLeftMouseDown,
strCoord,
Quartz.kCGMouseButtonLeft
)
# Queue the events
Quartz.CGEventPost(Quartz.CoreGraphics.kCGHIDEventTap, pressLeftButton)
# Wait for reponse of system, a fuzzy icon appears
time.sleep(5)
# Simulate mouse moving speed, k is slope
speed = round(1 / float(speed), 2)
xmoved = stopCoord[0] - strCoord[0]
ymoved = stopCoord[1] - strCoord[1]
if ymoved == 0:
raise ValueError('Not support horizontal moving')
else:
k = abs(ymoved / xmoved)
if xmoved != 0:
for xpos in range(int(abs(xmoved))):
if xmoved > 0 and ymoved > 0:
currcoord = (strCoord[0] + xpos, strCoord[1] + xpos * k)
elif xmoved > 0 and ymoved < 0:
currcoord = (strCoord[0] + xpos, strCoord[1] - xpos * k)
elif xmoved < 0 and ymoved < 0:
| python | {
"resource": ""
} |
q262298 | BaseAXUIElement._waitFor | validation | def _waitFor(self, timeout, notification, **kwargs):
"""Wait for a particular UI event to occur; this can be built
upon in NativeUIElement for specific convenience methods.
"""
callback = self._matchOther
retelem = None
callbackArgs = None
callbackKwargs = None
# Allow customization of the callback, though by default use the basic
# _match() method
if 'callback' in kwargs:
callback = kwargs['callback']
del kwargs['callback']
# Deal with these only if callback is provided:
if 'args' in kwargs:
if not isinstance(kwargs['args'], tuple):
errStr = 'Notification callback args not given as a tuple'
raise TypeError(errStr)
# If args are given, notification will pass back the returned
# element in the first positional arg
callbackArgs = kwargs['args']
del kwargs['args']
if 'kwargs' in kwargs:
if not isinstance(kwargs['kwargs'], dict):
errStr | python | {
"resource": ""
} |
q262299 | BaseAXUIElement._getActions | validation | def _getActions(self):
"""Retrieve a list of actions supported by the object."""
actions = _a11y.AXUIElement._getActions(self)
| python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.