_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 31 13.1k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10100 | ClassTracker._track_modify | train | def _track_modify(self, cls, name, detail, keep, trace):
"""
Modify settings of a tracked class
"""
| python | {
"resource": ""
} |
q10101 | ClassTracker._restore_constructor | train | def _restore_constructor(self, cls):
"""
Restore the original constructor, lose track of class.
"""
| python | {
"resource": ""
} |
q10102 | ClassTracker.track_change | train | def track_change(self, instance, resolution_level=0):
"""
Change tracking options for the already tracked object 'instance'.
If instance is not tracked, a KeyError will be | python | {
"resource": ""
} |
q10103 | ClassTracker.track_object | train | def track_object(self, instance, name=None, resolution_level=0, keep=False, trace=False):
"""
Track object 'instance' and sample size and lifetime information.
Not all objects can be tracked; trackable objects are class instances and
other objects that can be weakly referenced. When an o... | python | {
"resource": ""
} |
q10104 | ClassTracker.detach_all_classes | train | def detach_all_classes(self):
"""
Detach from all tracked classes.
"""
classes | python | {
"resource": ""
} |
q10105 | ClassTracker.detach_all | train | def detach_all(self):
"""
Detach from all tracked classes and objects.
Restore the original constructors and cleanse the tracking lists.
"""
| python | {
"resource": ""
} |
q10106 | ClassTracker.start_periodic_snapshots | train | def start_periodic_snapshots(self, interval=1.0):
"""
Start a thread which takes snapshots periodically. The `interval` specifies
the time in seconds the thread waits between taking snapshots. The thread is
started as a daemon allowing the program to exit. If periodic snapshots are
... | python | {
"resource": ""
} |
q10107 | ClassTracker.stop_periodic_snapshots | train | def stop_periodic_snapshots(self):
"""
Post a stop signal to the thread that takes the periodic snapshots. The
function waits for the thread to terminate which can take some time
depending on the configured interval.
"""
if self._periodic_thread | python | {
"resource": ""
} |
q10108 | ClassTracker.create_snapshot | train | def create_snapshot(self, description='', compute_total=False):
"""
Collect current per instance statistics and saves total amount of
memory associated with the Python process.
If `compute_total` is `True`, the total consumption of all objects
known to *asizeof* is computed. The... | python | {
"resource": ""
} |
q10109 | is_required | train | def is_required(action):
'''_actions which are positional or possessing the `required` flag '''
return not action.option_strings and not | python | {
"resource": ""
} |
q10110 | compute_ecc_hash | train | def compute_ecc_hash(ecc_manager, hasher, buf, max_block_size, rate, message_size=None, as_string=False):
'''Split a string in blocks given max_block_size and compute the hash and ecc for each block, and then return a nice list with both for easy processing.'''
result = []
# If required parameters were not ... | python | {
"resource": ""
} |
q10111 | ReferenceGraph._eliminate_leafs | train | def _eliminate_leafs(self, graph):
"""
Eliminate leaf objects - that are objects not referencing any other
objects in the list `graph`. Returns the list of objects without the
| python | {
"resource": ""
} |
q10112 | ReferenceGraph._reduce_to_cycles | train | def _reduce_to_cycles(self):
"""
Iteratively eliminate leafs to reduce the set of objects to only those
that build cycles. Return the number of objects involved in reference
cycles. If there are no cycles, `self.objects` will be an empty list and
this method returns 0.
""... | python | {
"resource": ""
} |
q10113 | ReferenceGraph.reduce_to_cycles | train | def reduce_to_cycles(self):
"""
Iteratively eliminate leafs to reduce the set of objects to only those
that build cycles. Return the reduced graph. If there are no cycles,
None is returned.
"""
if not self._reduced:
reduced = copy(self)
reduced.obj... | python | {
"resource": ""
} |
q10114 | ReferenceGraph._filter_group | train | def _filter_group(self, group):
"""
Eliminate all objects but those which belong to `group`.
``self.objects``, ``self.metadata`` and ``self.edges`` are modified.
Returns `True` if the group is non-empty. Otherwise returns `False`.
"""
self.metadata = [x for x in self.meta... | python | {
"resource": ""
} |
q10115 | ReferenceGraph.split | train | def split(self):
"""
Split the graph into sub-graphs. Only connected objects belong to the
same graph. `split` yields copies of the Graph object. Shallow copies
are used that only replicate the meta-information, but share the same
object list ``self.objects``.
>>> from p... | python | {
"resource": ""
} |
q10116 | ReferenceGraph.split_and_sort | train | def split_and_sort(self):
"""
Split the graphs into sub graphs and return a list of all graphs sorted
by the number of nodes. The graph with most nodes is returned first.
"""
graphs = list(self.split())
graphs.sort(key=lambda x: | python | {
"resource": ""
} |
q10117 | ReferenceGraph._annotate_objects | train | def _annotate_objects(self):
"""
Extract meta-data describing the stored objects.
"""
self.metadata = []
sizer = Asizer()
sizes = sizer.asizesof(*self.objects)
self.total_size = sizer.total
for obj, sz in zip(self.objects, sizes):
md = _MetaObj... | python | {
"resource": ""
} |
q10118 | ReferenceGraph._get_graphviz_data | train | def _get_graphviz_data(self):
"""
Emit a graph representing the connections between the objects described
within the metadata list. The text representation can be transformed to
a graph with graphviz. Returns a string.
"""
s = []
header = '// Process this file wit... | python | {
"resource": ""
} |
q10119 | ReferenceGraph.write_graph | train | def write_graph(self, filename):
"""
Write raw graph data which can be post-processed using graphviz.
"""
| python | {
"resource": ""
} |
q10120 | Profiler.root_frame | train | def root_frame(self):
"""
Returns the parsed results in the form of a tree of Frame objects
"""
if not hasattr(self, '_root_frame'):
self._root_frame = Frame()
# define a recursive function that builds the hierarchy of frames given the
# stack of fram... | python | {
"resource": ""
} |
q10121 | is_module_stdlib | train | def is_module_stdlib(file_name):
"""Returns True if the file_name is in the lib directory."""
# TODO: Move these calls away from this function so it doesn't have to run
# every time.
lib_path = sysconfig.get_python_lib() | python | {
"resource": ""
} |
q10122 | tracer | train | def tracer(frame, event, arg):
"""This is an internal function that is called every time a call is made
during a trace. It keeps track of relationships between calls.
"""
global func_count_max
global func_count
global trace_filter
global time_filter
global call_stack
global func_time... | python | {
"resource": ""
} |
q10123 | get_dot | train | def get_dot(stop=True):
"""Returns a string containing a DOT file. Setting stop to True will cause
the trace to stop.
"""
defaults = []
nodes = []
edges = []
# define default attributes
for comp, comp_attr in graph_attributes.items():
attr = ', '.join( '%s = "%s"' % (attr... | python | {
"resource": ""
} |
q10124 | get_gdf | train | def get_gdf(stop=True):
"""Returns a string containing a GDF file. Setting stop to True will cause
the trace to stop.
"""
ret = ['nodedef>name VARCHAR, label VARCHAR, hits INTEGER, ' + \
'calls_frac DOUBLE, total_time_frac DOUBLE, ' + \
'total_time DOUBLE, color VARCHAR, width DO... | python | {
"resource": ""
} |
q10125 | make_dot_graph | train | def make_dot_graph(filename, format='png', tool='dot', stop=True):
"""Creates a graph using a Graphviz tool that supports the dot language. It
will output into a file specified by filename with the format specified.
Setting stop to True will stop the current trace.
"""
if stop:
stop_trace()
... | python | {
"resource": ""
} |
q10126 | make_gdf_graph | train | def make_gdf_graph(filename, stop=True):
"""Create a graph in simple GDF format, suitable for feeding into Gephi,
or some other graph manipulation and display | python | {
"resource": ""
} |
q10127 | simple_memoize | train | def simple_memoize(callable_object):
"""Simple memoization for functions without keyword arguments.
This is useful for mapping code objects to module in this context.
inspect.getmodule() requires a number of system calls, which may slow down
the tracing considerably. Caching the mapping from code objec... | python | {
"resource": ""
} |
q10128 | macshim | train | def macshim():
"""Shim to run 32-bit on 64-bit mac as a sub-process"""
import subprocess, sys
subprocess.call([
sys.argv[0] + '32'
| python | {
"resource": ""
} |
q10129 | ECCMan.check | train | def check(self, message, ecc, k=None):
'''Check if there's any error in a message+ecc. Can be used before decoding, in addition to hashes to detect if the message was tampered, or after decoding to check that the message was fully recovered.'''
| python | {
"resource": ""
} |
q10130 | ECCMan.description | train | def description(self):
'''Provide a description for each algorithm available, useful to print in ecc file'''
if 0 < self.algo <= 3:
return "Reed-Solomon with polynomials in Galois field of characteristic %i (2^%i) with generator=%s, prime poly=%s and first consecutive root=%s." % (self.field... | python | {
"resource": ""
} |
q10131 | profile | train | def profile(fn=None, skip=0, filename=None, immediate=False, dirs=False,
sort=None, entries=40,
profiler=('cProfile', 'profile', 'hotshot')):
"""Mark `fn` for profiling.
If `skip` is > 0, first `skip` calls to `fn` will not be profiled.
If `immediate` is False, profiling results wi... | python | {
"resource": ""
} |
q10132 | timecall | train | def timecall(fn=None, immediate=True, timer=time.time):
"""Wrap `fn` and print its execution time.
Example::
@timecall
def somefunc(x, y):
time.sleep(x * y)
somefunc(2, 3)
will print the time taken by somefunc on every call. If you want just
a summary at program ... | python | {
"resource": ""
} |
q10133 | FuncProfile.print_stats | train | def print_stats(self):
"""Print profile information to sys.stdout."""
funcname = self.fn.__name__
filename = self.fn.__code__.co_filename
lineno = self.fn.__code__.co_firstlineno
print("")
print("*** PROFILER RESULTS ***")
print("%s (%s:%s)" % (funcname, filename,... | python | {
"resource": ""
} |
q10134 | FuncProfile.reset_stats | train | def reset_stats(self):
"""Reset accumulated profiler statistics."""
# Note: not using self.Profile, | python | {
"resource": ""
} |
q10135 | TraceFuncCoverage.atexit | train | def atexit(self):
"""Stop profiling and print profile information to sys.stderr.
This function is registered as an atexit hook.
"""
funcname = self.fn.__name__
filename = self.fn.__code__.co_filename
lineno = self.fn.__code__.co_firstlineno
print("")
prin... | python | {
"resource": ""
} |
q10136 | FuncSource.find_source_lines | train | def find_source_lines(self):
"""Mark all executable source lines in fn as executed 0 times."""
strs = trace.find_strings(self.filename)
lines = trace.find_lines_from_code(self.fn.__code__, strs)
self.firstcodelineno = sys.maxint
for lineno in lines:
| python | {
"resource": ""
} |
q10137 | FuncSource.mark | train | def mark(self, lineno, count=1):
"""Mark a given source line as executed count times.
Multiple calls to mark for the same lineno add up.
| python | {
"resource": ""
} |
q10138 | FuncSource.count_never_executed | train | def count_never_executed(self):
"""Count statements that were never executed."""
lineno = self.firstlineno
counter = 0
for line in self.source:
if self.sourcelines.get(lineno) == 0:
| python | {
"resource": ""
} |
q10139 | SimpleAudioIndexer._split_audio_by_duration | train | def _split_audio_by_duration(self, audio_abs_path,
results_abs_path, duration_seconds):
"""
Calculates the length of each segment and passes it to
self._audio_segment_extractor
Parameters
----------
audio_abs_path : str
results_ab... | python | {
"resource": ""
} |
q10140 | SimpleAudioIndexer._filtering_step | train | def _filtering_step(self, basename):
"""
Moves the audio file if the format is `wav` to `filtered` directory.
Parameters
----------
basename : str
A basename of `/home/random-guy/some-audio-file.wav` is
`some-audio-file.wav`
"""
name = ''.... | python | {
"resource": ""
} |
q10141 | SimpleAudioIndexer._prepare_audio | train | def _prepare_audio(self, basename, replace_already_indexed=False):
"""
Prepares and stages the audio file to be indexed.
Parameters
----------
basename : str, None
A basename of `/home/random-guy/some-audio-file.wav` is
`some-audio-file.wav`
I... | python | {
"resource": ""
} |
q10142 | SimpleAudioIndexer._index_audio_cmu | train | def _index_audio_cmu(self, basename=None, replace_already_indexed=False):
"""
Indexes audio with pocketsphinx. Beware that the output would not be
sufficiently accurate. Use this only if you don't want to upload your
files to IBM.
Parameters
-----------
basename ... | python | {
"resource": ""
} |
q10143 | SimpleAudioIndexer._index_audio_ibm | train | def _index_audio_ibm(self, basename=None, replace_already_indexed=False,
continuous=True, model="en-US_BroadbandModel",
word_confidence=True, word_alternatives_threshold=0.9,
profanity_filter_for_US_results=False):
"""
Implements... | python | {
"resource": ""
} |
q10144 | SimpleAudioIndexer.index_audio | train | def index_audio(self, *args, **kwargs):
"""
Calls the correct indexer function based on the mode.
If mode is `ibm`, _indexer_audio_ibm is called which is an interface
for Watson. Note that some of the explaination of _indexer_audio_ibm's
arguments is from [1]_
If mode i... | python | {
"resource": ""
} |
q10145 | SimpleAudioIndexer._timestamp_regulator | train | def _timestamp_regulator(self):
"""
Makes a dictionary whose keys are audio file basenames and whose
values are a list of word blocks from unregulated timestamps and
updates the main timestamp attribute. After all done, purges
unregulated ones.
In case the audio file was ... | python | {
"resource": ""
} |
q10146 | SimpleAudioIndexer.save_indexed_audio | train | def save_indexed_audio(self, indexed_audio_file_abs_path):
"""
Writes the corrected timestamps to a file. Timestamps are a python
dictionary.
Parameters
----------
indexed_audio_file_abs_path : str
| python | {
"resource": ""
} |
q10147 | SimpleAudioIndexer._partial_search_validator | train | def _partial_search_validator(self, sub, sup, anagram=False,
subsequence=False, supersequence=False):
"""
It's responsible for validating the partial results of `search` method.
If it returns True, the search would return its result. Else, search
method ... | python | {
"resource": ""
} |
q10148 | SimpleAudioIndexer.search_all | train | def search_all(self, queries, audio_basename=None, case_sensitive=False,
subsequence=False, supersequence=False, timing_error=0.0,
anagram=False, missing_word_tolerance=0):
"""
Returns a dictionary of all results of all of the queries for all of
the audio fi... | python | {
"resource": ""
} |
q10149 | SimpleAudioIndexer.search_regexp | train | def search_regexp(self, pattern, audio_basename=None):
"""
First joins the words of the word_blocks of timestamps with space, per
audio_basename. Then matches `pattern` and calculates the index of the
word_block where the first and last word of the matched result appears
in. Then... | python | {
"resource": ""
} |
q10150 | gf_poly_mul_simple | train | def gf_poly_mul_simple(p, q): # simple equivalent way of multiplying two polynomials without precomputation, but thus it's slower
'''Multiply two polynomials, inside Galois Field'''
# Pre-allocate the result array
r = bytearray(len(p) + len(q) - 1)
# Compute the polynomial multiplication (just like the ... | python | {
"resource": ""
} |
q10151 | rs_correct_msg | train | def rs_correct_msg(msg_in, nsym, fcr=0, generator=2, erase_pos=None, only_erasures=False):
'''Reed-Solomon main decoding function'''
global field_charac
if len(msg_in) > field_charac:
# Note that it is in fact possible to encode/decode messages that are longer than field_charac, but because this wil... | python | {
"resource": ""
} |
q10152 | rs_correct_msg_nofsynd | train | def rs_correct_msg_nofsynd(msg_in, nsym, fcr=0, generator=2, erase_pos=None, only_erasures=False):
'''Reed-Solomon main decoding function, without using the modified Forney syndromes'''
global field_charac
if len(msg_in) > field_charac:
raise ValueError("Message is too long (%i when max is %i)" % (l... | python | {
"resource": ""
} |
q10153 | RSCodec.decode | train | def decode(self, data, erase_pos=None, only_erasures=False):
'''Repair a message, whatever its size is, by using chunking'''
# erase_pos is a list of positions where you know (or greatly suspect at least) there is an erasure (ie, wrong character but you know it's at this position). Just input the list o... | python | {
"resource": ""
} |
q10154 | find_loops | train | def find_loops( record, index, stop_types = STOP_TYPES, open=None, seen = None ):
"""Find all loops within the index and replace with loop records"""
if open is None:
open = []
if seen is None:
seen = set()
for child in children( record, index, stop_types = stop_types ):
if child... | python | {
"resource": ""
} |
q10155 | promote_loops | train | def promote_loops( loops, index, shared ):
"""Turn loops into "objects" that can be processed normally"""
for loop in loops:
loop = list(loop)
members = [index[addr] for addr in loop]
external_parents = list(set([
addr for addr in sum([shared.get(addr,[]) for addr in loop],[]... | python | {
"resource": ""
} |
q10156 | children | train | def children( record, index, key='refs', stop_types=STOP_TYPES ):
"""Retrieve children records for given record"""
result = []
for ref in record.get( key,[]):
try:
record = index[ref]
except KeyError, err:
#print 'No record for %s address %s in %s'%(key, ref, record['... | python | {
"resource": ""
} |
q10157 | children_types | train | def children_types( record, index, key='refs', stop_types=STOP_TYPES ):
"""Produce dictionary mapping type-key to instances for all children"""
types = {}
for child in children( | python | {
"resource": ""
} |
q10158 | recurse_module | train | def recurse_module( overall_record, index, shared, stop_types=STOP_TYPES, already_seen=None, min_size=0 ):
"""Creates a has-a recursive-cost hierarchy
Mutates objects in-place to produce a hierarchy of memory usage based on
reference-holding cost assignment
"""
for record in recurse(
... | python | {
"resource": ""
} |
q10159 | simple | train | def simple( child, shared, parent ):
"""Return sub-set of children who are "simple" in the sense of group_children"""
return (
| python | {
"resource": ""
} |
q10160 | deparent_unreachable | train | def deparent_unreachable( reachable, shared ):
"""Eliminate all parent-links from unreachable objects from reachable objects
"""
for id,shares in shared.iteritems():
if id in reachable: # child is reachable
filtered = [
x
for x in shares
| python | {
"resource": ""
} |
q10161 | bind_parents | train | def bind_parents( index, shared ):
"""Set parents on all items in | python | {
"resource": ""
} |
q10162 | find_roots | train | def find_roots( disconnected, index, shared ):
"""Find appropriate "root" objects from which to recurse the hierarchies
Will generate a synthetic root for anything which doesn't have any parents...
"""
log.warn( '%s disconnected objects in %s total objects', len(disconnected), len(index))
natur... | python | {
"resource": ""
} |
q10163 | Loader.get_root | train | def get_root( self, key ):
"""Retrieve the given root by type-key"""
if key not in self.roots:
root,self.rows = load( self.filename, include_interpreter = | python | {
"resource": ""
} |
q10164 | Dinergate.url | train | def url(self):
"""The fetching target URL.
The default behavior of this property is build URL string with the
:const:`~brownant.dinergate.Dinergate.URL_TEMPLATE`.
| python | {
"resource": ""
} |
q10165 | Site.record_action | train | def record_action(self, method_name, *args, **kwargs):
"""Record the method-calling action.
The actions expect to be played on an target object.
:param method_name: the name of called method.
:param args: the general arguments for calling method.
| python | {
"resource": ""
} |
q10166 | Site.play_actions | train | def play_actions(self, target):
"""Play record actions on the target object.
:param target: the target which recive all record actions, is a brown
ant app instance normally.
:type target: :class:`~brownant.app.Brownant`
| python | {
"resource": ""
} |
q10167 | Site.route | train | def route(self, host, rule, **options):
"""The decorator to register wrapped function as the brown ant app.
All optional parameters of this method are compatible with the
:meth:`~brownant.app.Brownant.add_url_rule`.
Registered functions or classes must be import-able with its qualified... | python | {
"resource": ""
} |
q10168 | to_bytes_safe | train | def to_bytes_safe(text, encoding="utf-8"):
"""Convert the input value into bytes type.
If the input value is string type and could be encode as UTF-8 bytes, the
encoded value will be returned. Otherwise, the encoding has failed, the
origin value will be returned as well.
:param text: the input val... | python | {
"resource": ""
} |
q10169 | Brownant.add_url_rule | train | def add_url_rule(self, host, rule_string, endpoint, **options):
"""Add a url rule to the app instance.
The url rule is the same with Flask apps and other Werkzeug apps.
:param host: the matched hostname. e.g. "www.python.org"
:param rule_string: the matched path pattern. e.g. "/news/<i... | python | {
"resource": ""
} |
q10170 | Brownant.parse_url | train | def parse_url(self, url_string):
"""Parse the URL string with the url map of this app instance.
:param url_string: the origin URL string.
:returns: the tuple as `(url, url_adapter, query_args)`, the url is
parsed by the standard library `urlparse`, the url_adapter is
... | python | {
"resource": ""
} |
q10171 | Brownant.dispatch_url | train | def dispatch_url(self, url_string):
"""Dispatch the URL string to the target endpoint function.
:param url_string: the origin URL string.
:returns: the return value of calling dispatched function.
"""
url, url_adapter, query_args = self.parse_url(url_string)
try:
... | python | {
"resource": ""
} |
q10172 | Brownant.mount_site | train | def mount_site(self, site):
"""Mount a supported site to this app instance.
:param site: the site instance be mounted.
"""
| python | {
"resource": ""
} |
q10173 | Github.githubWebHookConsumer | train | def githubWebHookConsumer(self, *args, **kwargs):
"""
Consume GitHub WebHook
Capture a GitHub event and publish it via pulse, | python | {
"resource": ""
} |
q10174 | Github.badge | train | def badge(self, *args, **kwargs):
"""
Latest Build Status Badge
Checks the status of the latest build of a given branch
and returns corresponding badge svg.
| python | {
"resource": ""
} |
q10175 | Github.createComment | train | def createComment(self, *args, **kwargs):
"""
Post a comment on a given GitHub Issue or Pull Request
For a given Issue or Pull Request of a repository, | python | {
"resource": ""
} |
q10176 | lorem_gotham | train | def lorem_gotham():
"""Cheesy Gothic Poetry Generator
Uses Python generators to yield eternal angst.
When you need to generate random verbiage to test your code or
typographic design, let's face it... Lorem Ipsum and "the quick
brown fox" are old and boring!
What you need is something with *f... | python | {
"resource": ""
} |
q10177 | lorem_gotham_title | train | def lorem_gotham_title():
"""Names your poem
"""
w = lambda l: l[random.randrange(len(l))]
sentence = lambda *l: lambda: " ".join(l)
pick = lambda *l: (l[random.randrange(len(l))])()
return pick(
| python | {
"resource": ""
} |
q10178 | main | train | def main():
"""I provide a command-line interface for this module
"""
print()
print("-~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~--~*~-")
print(lorem_gotham_title().center(50))
| python | {
"resource": ""
} |
q10179 | EC2Manager.listWorkerTypes | train | async def listWorkerTypes(self, *args, **kwargs):
"""
See the list of worker types which are known to be managed
This method is only for debugging the ec2-manager
This method gives output: ``v1/list-worker-types.json#``
| python | {
"resource": ""
} |
q10180 | EC2Manager.runInstance | train | async def runInstance(self, *args, **kwargs):
"""
Run an instance
Request an instance of a worker type
This method takes input: ``v1/run-instance-request.json#``
This method | python | {
"resource": ""
} |
q10181 | EC2Manager.workerTypeStats | train | async def workerTypeStats(self, *args, **kwargs):
"""
Look up the resource stats for a workerType
Return an object which has a generic state description. This only contains counts of instances
This method gives | python | {
"resource": ""
} |
q10182 | EC2Manager.workerTypeHealth | train | async def workerTypeHealth(self, *args, **kwargs):
"""
Look up the resource health for a workerType
Return a view of the health of a | python | {
"resource": ""
} |
q10183 | EC2Manager.workerTypeErrors | train | async def workerTypeErrors(self, *args, **kwargs):
"""
Look up the most recent errors of a workerType
Return a list of the most recent errors encountered | python | {
"resource": ""
} |
q10184 | EC2Manager.workerTypeState | train | async def workerTypeState(self, *args, **kwargs):
"""
Look up the resource state for a workerType
Return state information for a given worker type
This method gives output: ``v1/worker-type-state.json#``
| python | {
"resource": ""
} |
q10185 | EC2Manager.ensureKeyPair | train | async def ensureKeyPair(self, *args, **kwargs):
"""
Ensure a KeyPair for a given worker type exists
Idempotently ensure that a keypair of a | python | {
"resource": ""
} |
q10186 | EC2Manager.removeKeyPair | train | async def removeKeyPair(self, *args, **kwargs):
"""
Ensure a KeyPair for a given worker type does not exist
Ensure that a keypair of a given name does not exist.
| python | {
"resource": ""
} |
q10187 | EC2Manager.terminateInstance | train | async def terminateInstance(self, *args, **kwargs):
"""
Terminate an instance
Terminate an instance in a | python | {
"resource": ""
} |
q10188 | EC2Manager.getHealth | train | async def getHealth(self, *args, **kwargs):
"""
Get EC2 account health metrics
Give some basic stats on the health of our EC2 account
This method gives output: ``v1/health.json#``
| python | {
"resource": ""
} |
q10189 | EC2Manager.getRecentErrors | train | async def getRecentErrors(self, *args, **kwargs):
"""
Look up the most recent errors in the provisioner across all worker types
Return a list | python | {
"resource": ""
} |
q10190 | EC2Manager.regions | train | async def regions(self, *args, **kwargs):
"""
See the list of regions managed by this ec2-manager
This method is only for debugging the ec2-manager
This method | python | {
"resource": ""
} |
q10191 | EC2Manager.amiUsage | train | async def amiUsage(self, *args, **kwargs):
"""
See the list of AMIs and their usage
List AMIs and their usage by returning a list of objects in the form:
| python | {
"resource": ""
} |
q10192 | EC2Manager.ebsUsage | train | async def ebsUsage(self, *args, **kwargs):
"""
See the current EBS volume usage list
Lists current EBS volume usage by returning a list of objects
that are uniquely defined by {region, volumetype, state} in the form:
{
region: string,
volumetype: string,
... | python | {
"resource": ""
} |
q10193 | EC2Manager.dbpoolStats | train | async def dbpoolStats(self, *args, **kwargs):
"""
Statistics on the Database client pool
This method is only for debugging the ec2-manager
This method is | python | {
"resource": ""
} |
q10194 | EC2Manager.sqsStats | train | async def sqsStats(self, *args, **kwargs):
"""
Statistics on the sqs queues
This method is only for debugging the ec2-manager
This method is ``experimental`` | python | {
"resource": ""
} |
q10195 | EC2Manager.purgeQueues | train | async def purgeQueues(self, *args, **kwargs):
"""
Purge the SQS queues
This method is only for debugging the ec2-manager
This method is ``experimental``
| python | {
"resource": ""
} |
q10196 | GithubEvents.pullRequest | train | def pullRequest(self, *args, **kwargs):
"""
GitHub Pull Request Event
When a GitHub pull request event is posted it will be broadcast on this
exchange with the designated `organization` and `repository`
in the routing-key along with event specific metadata in the payload.
... | python | {
"resource": ""
} |
q10197 | GithubEvents.push | train | def push(self, *args, **kwargs):
"""
GitHub push Event
When a GitHub push event is posted it will be broadcast on this
exchange with the designated `organization` and `repository`
in the routing-key along with event specific metadata in the payload.
This exchange output... | python | {
"resource": ""
} |
q10198 | GithubEvents.release | train | def release(self, *args, **kwargs):
"""
GitHub release Event
When a GitHub release event is posted it will be broadcast on this
exchange with the designated `organization` and `repository`
in the routing-key along with event specific metadata in the payload.
This exchan... | python | {
"resource": ""
} |
q10199 | GithubEvents.taskGroupCreationRequested | train | def taskGroupCreationRequested(self, *args, **kwargs):
"""
tc-gh requested the Queue service to create all the tasks in a group
supposed to signal that taskCreate API has been called for every task in the task group
for this particular repo and this particular organization
curre... | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.