id_within_dataset int64 1 55.5k | snippet stringlengths 19 14.2k | tokens listlengths 6 1.63k | nl stringlengths 6 352 | split_within_dataset stringclasses 1 value | is_duplicated bool 2 classes |
|---|---|---|---|---|---|
4,985 | def run_recover_tasks(host, guest, instance, on_migration_failure):
while on_migration_failure:
task = on_migration_failure.popleft()
if (task == 'unpause'):
try:
state = guest.get_power_state(host)
if (state == power_state.PAUSED):
guest.resume()
except Exception as e:
LOG.warning(_LW('Failed to resume paused instance before live-migration rollback %s'), e, instance=instance)
else:
LOG.warning(_LW("Unknown migration task '%(task)s'"), {'task': task}, instance=instance)
| [
"def",
"run_recover_tasks",
"(",
"host",
",",
"guest",
",",
"instance",
",",
"on_migration_failure",
")",
":",
"while",
"on_migration_failure",
":",
"task",
"=",
"on_migration_failure",
".",
"popleft",
"(",
")",
"if",
"(",
"task",
"==",
"'unpause'",
")",
":",
... | run any pending migration recovery tasks . | train | false |
4,986 | def strip_trailing_semicolon(query):
s = _SEMICOLON_WHITESPACE.split(query, 2)
if (len(s) > 1):
assert (len(s) == 2)
assert (s[1] == '')
return s[0]
| [
"def",
"strip_trailing_semicolon",
"(",
"query",
")",
":",
"s",
"=",
"_SEMICOLON_WHITESPACE",
".",
"split",
"(",
"query",
",",
"2",
")",
"if",
"(",
"len",
"(",
"s",
")",
">",
"1",
")",
":",
"assert",
"(",
"len",
"(",
"s",
")",
"==",
"2",
")",
"as... | as a convenience . | train | false |
4,988 | def _get_node(lb, node_id=None, address=None, port=None):
for node in getattr(lb, 'nodes', []):
match_list = []
if (node_id is not None):
match_list.append((getattr(node, 'id', None) == node_id))
if (address is not None):
match_list.append((getattr(node, 'address', None) == address))
if (port is not None):
match_list.append((getattr(node, 'port', None) == port))
if (match_list and all(match_list)):
return node
return None
| [
"def",
"_get_node",
"(",
"lb",
",",
"node_id",
"=",
"None",
",",
"address",
"=",
"None",
",",
"port",
"=",
"None",
")",
":",
"for",
"node",
"in",
"getattr",
"(",
"lb",
",",
"'nodes'",
",",
"[",
"]",
")",
":",
"match_list",
"=",
"[",
"]",
"if",
... | helper function that returns all information about a named node . | train | false |
4,989 | def fxa_authorize(request):
return render(request, 'commonplace/fxa_authorize.html')
| [
"def",
"fxa_authorize",
"(",
"request",
")",
":",
"return",
"render",
"(",
"request",
",",
"'commonplace/fxa_authorize.html'",
")"
] | a page to mimic commonplaces fxa-authorize page to handle login . | train | false |
4,990 | def chshell(name, shell):
pre_info = info(name)
if (not pre_info):
raise CommandExecutionError("User '{0}' does not exist".format(name))
if (shell == pre_info['shell']):
return True
cmd = ['pw', 'usermod', '-s', shell, '-n', name]
__salt__['cmd.run'](cmd, python_shell=False)
return (info(name).get('shell') == shell)
| [
"def",
"chshell",
"(",
"name",
",",
"shell",
")",
":",
"pre_info",
"=",
"info",
"(",
"name",
")",
"if",
"(",
"not",
"pre_info",
")",
":",
"raise",
"CommandExecutionError",
"(",
"\"User '{0}' does not exist\"",
".",
"format",
"(",
"name",
")",
")",
"if",
... | change the default shell of the user cli example: . | train | true |
4,991 | def getNextChildIndex(elementNode):
for (childNodeIndex, childNode) in enumerate(elementNode.parentNode.childNodes):
if (childNode == elementNode):
return (childNodeIndex + 1)
return len(elementNode.parentNode.childNodes)
| [
"def",
"getNextChildIndex",
"(",
"elementNode",
")",
":",
"for",
"(",
"childNodeIndex",
",",
"childNode",
")",
"in",
"enumerate",
"(",
"elementNode",
".",
"parentNode",
".",
"childNodes",
")",
":",
"if",
"(",
"childNode",
"==",
"elementNode",
")",
":",
"retu... | get the next child index . | train | false |
4,993 | def get_url_path(path, use_directory_urls=True):
path = get_html_path(path)
url = (u'/' + path.replace(os.path.sep, u'/'))
if use_directory_urls:
return url[:(- len(u'index.html'))]
return url
| [
"def",
"get_url_path",
"(",
"path",
",",
"use_directory_urls",
"=",
"True",
")",
":",
"path",
"=",
"get_html_path",
"(",
"path",
")",
"url",
"=",
"(",
"u'/'",
"+",
"path",
".",
"replace",
"(",
"os",
".",
"path",
".",
"sep",
",",
"u'/'",
")",
")",
"... | map a source file path to an output html path . | train | false |
4,994 | def _clean_object_name(name):
return (urlquote(name, safe='') if name else None)
| [
"def",
"_clean_object_name",
"(",
"name",
")",
":",
"return",
"(",
"urlquote",
"(",
"name",
",",
"safe",
"=",
"''",
")",
"if",
"name",
"else",
"None",
")"
] | return the url encoded name . | train | false |
4,995 | @pytest.fixture
def _history():
history = InMemoryHistory()
history.append(u'alpha beta gamma delta')
history.append(u'one two three four')
return history
| [
"@",
"pytest",
".",
"fixture",
"def",
"_history",
"(",
")",
":",
"history",
"=",
"InMemoryHistory",
"(",
")",
"history",
".",
"append",
"(",
"u'alpha beta gamma delta'",
")",
"history",
".",
"append",
"(",
"u'one two three four'",
")",
"return",
"history"
] | prefilled history . | train | false |
4,996 | def simplify_regex(pattern):
pattern = named_group_matcher.sub((lambda m: m.group(1)), pattern)
pattern = non_named_group_matcher.sub('<var>', pattern)
pattern = pattern.replace('^', '').replace('$', '').replace('?', '').replace('//', '/').replace('\\', '')
if (not pattern.startswith('/')):
pattern = ('/' + pattern)
return pattern
| [
"def",
"simplify_regex",
"(",
"pattern",
")",
":",
"pattern",
"=",
"named_group_matcher",
".",
"sub",
"(",
"(",
"lambda",
"m",
":",
"m",
".",
"group",
"(",
"1",
")",
")",
",",
"pattern",
")",
"pattern",
"=",
"non_named_group_matcher",
".",
"sub",
"(",
... | clean up urlpattern regexes into something more readable by humans . | train | false |
4,999 | def _unpick_search(sort, allowed_fields=None, total=None):
sorts = []
split_sort = sort.split(',')
for part in split_sort:
split_part = part.strip().split()
field = split_part[0]
if (len(split_part) > 1):
order = split_part[1].lower()
else:
order = 'asc'
if allowed_fields:
if (field not in allowed_fields):
raise ValidationError(('Cannot sort by field `%s`' % field))
if (order not in ['asc', 'desc']):
raise ValidationError(('Invalid sort direction `%s`' % order))
sorts.append((field, order))
if (total and (len(sorts) > total)):
raise ValidationError(('Too many sort criteria provided only %s allowed' % total))
return sorts
| [
"def",
"_unpick_search",
"(",
"sort",
",",
"allowed_fields",
"=",
"None",
",",
"total",
"=",
"None",
")",
":",
"sorts",
"=",
"[",
"]",
"split_sort",
"=",
"sort",
".",
"split",
"(",
"','",
")",
"for",
"part",
"in",
"split_sort",
":",
"split_part",
"=",
... | this is a helper function that takes a sort string eg name asc . | train | false |
5,000 | def _fill_and_one_pad_stride(stride, n):
try:
return (((1,) + _fill_shape(stride, n)) + (1,))
except TypeError:
raise base.IncompatibleShapeError('stride is {} ({}), must be either an integer or an iterable of integers of size {}'.format(stride, type(stride), n))
| [
"def",
"_fill_and_one_pad_stride",
"(",
"stride",
",",
"n",
")",
":",
"try",
":",
"return",
"(",
"(",
"(",
"1",
",",
")",
"+",
"_fill_shape",
"(",
"stride",
",",
"n",
")",
")",
"+",
"(",
"1",
",",
")",
")",
"except",
"TypeError",
":",
"raise",
"b... | expands the provided stride to size n and pads it with 1s . | train | false |
5,001 | def make_sample_query_from_filter(sample_filter, require_meter=True):
meter = sample_filter.meter
if ((not meter) and require_meter):
raise RuntimeError('Missing required meter specifier')
(start_row, end_row, ts_query) = make_timestamp_query(make_general_rowkey_scan, start=sample_filter.start_timestamp, start_op=sample_filter.start_timestamp_op, end=sample_filter.end_timestamp, end_op=sample_filter.end_timestamp_op, some_id=meter)
kwargs = dict(user_id=sample_filter.user, project_id=sample_filter.project, counter_name=meter, resource_id=sample_filter.resource, source=sample_filter.source, message_id=sample_filter.message_id)
q = make_query(metaquery=sample_filter.metaquery, **kwargs)
if q:
res_q = (((q + ' AND ') + ts_query) if ts_query else q)
else:
res_q = (ts_query if ts_query else None)
need_timestamp = ((sample_filter.start_timestamp or sample_filter.end_timestamp) is not None)
columns = get_meter_columns(metaquery=sample_filter.metaquery, need_timestamp=need_timestamp, **kwargs)
return (res_q, start_row, end_row, columns)
| [
"def",
"make_sample_query_from_filter",
"(",
"sample_filter",
",",
"require_meter",
"=",
"True",
")",
":",
"meter",
"=",
"sample_filter",
".",
"meter",
"if",
"(",
"(",
"not",
"meter",
")",
"and",
"require_meter",
")",
":",
"raise",
"RuntimeError",
"(",
"'Missi... | return a query dictionary based on the settings in the filter . | train | false |
5,002 | def _PutSigningKeyset(io_loop, secret):
_GetSecretsManager().PutSecret(secret, json.dumps(secrets.CreateSigningKeyset(secret)))
io_loop.stop()
| [
"def",
"_PutSigningKeyset",
"(",
"io_loop",
",",
"secret",
")",
":",
"_GetSecretsManager",
"(",
")",
".",
"PutSecret",
"(",
"secret",
",",
"json",
".",
"dumps",
"(",
"secrets",
".",
"CreateSigningKeyset",
"(",
"secret",
")",
")",
")",
"io_loop",
".",
"stop... | creates a new keyczar crypt keyset used for signing and signature verification and writes it to secrets subdir . | train | false |
5,003 | def check_phylip_reject_duplicate():
handle = StringIO()
sequences = [SeqRecord(Seq('AAAA'), id='longsequencename1'), SeqRecord(Seq('AAAA'), id='longsequencename2'), SeqRecord(Seq('AAAA'), id='other_sequence')]
alignment = MultipleSeqAlignment(sequences)
try:
AlignIO.write(alignment, handle, 'phylip')
assert False, 'Duplicate IDs after truncation are not allowed.'
except ValueError as e:
assert ("Repeated name 'longsequen'" in str(e))
| [
"def",
"check_phylip_reject_duplicate",
"(",
")",
":",
"handle",
"=",
"StringIO",
"(",
")",
"sequences",
"=",
"[",
"SeqRecord",
"(",
"Seq",
"(",
"'AAAA'",
")",
",",
"id",
"=",
"'longsequencename1'",
")",
",",
"SeqRecord",
"(",
"Seq",
"(",
"'AAAA'",
")",
... | ensure that attempting to write sequences with duplicate ids after truncation fails for phylip format . | train | false |
5,004 | def idz_sfrmi(l, m):
return _id.idz_sfrmi(l, m)
| [
"def",
"idz_sfrmi",
"(",
"l",
",",
"m",
")",
":",
"return",
"_id",
".",
"idz_sfrmi",
"(",
"l",
",",
"m",
")"
] | initialize data for :func:idz_sfrm . | train | false |
5,005 | def write_bem_solution(fname, bem):
_check_bem_size(bem['surfs'])
with start_file(fname) as fid:
start_block(fid, FIFF.FIFFB_BEM)
write_int(fid, FIFF.FIFF_BEM_COORD_FRAME, bem['surfs'][0]['coord_frame'])
_write_bem_surfaces_block(fid, bem['surfs'])
if ('solution' in bem):
if (bem['bem_method'] != FIFF.FWD_BEM_LINEAR_COLL):
raise RuntimeError('Only linear collocation supported')
write_int(fid, FIFF.FIFF_BEM_APPROX, FIFF.FIFFV_BEM_APPROX_LINEAR)
write_float_matrix(fid, FIFF.FIFF_BEM_POT_SOLUTION, bem['solution'])
end_block(fid, FIFF.FIFFB_BEM)
end_file(fid)
| [
"def",
"write_bem_solution",
"(",
"fname",
",",
"bem",
")",
":",
"_check_bem_size",
"(",
"bem",
"[",
"'surfs'",
"]",
")",
"with",
"start_file",
"(",
"fname",
")",
"as",
"fid",
":",
"start_block",
"(",
"fid",
",",
"FIFF",
".",
"FIFFB_BEM",
")",
"write_int... | write a bem model with solution . | train | false |
5,006 | def test_tf_mxne():
alpha_space = 10.0
alpha_time = 5.0
(M, G, active_set) = _generate_tf_data()
(X_hat_tf, active_set_hat_tf, E) = tf_mixed_norm_solver(M, G, alpha_space, alpha_time, maxit=200, tol=1e-08, verbose=True, n_orient=1, tstep=4, wsize=32)
assert_array_equal(np.where(active_set_hat_tf)[0], active_set)
| [
"def",
"test_tf_mxne",
"(",
")",
":",
"alpha_space",
"=",
"10.0",
"alpha_time",
"=",
"5.0",
"(",
"M",
",",
"G",
",",
"active_set",
")",
"=",
"_generate_tf_data",
"(",
")",
"(",
"X_hat_tf",
",",
"active_set_hat_tf",
",",
"E",
")",
"=",
"tf_mixed_norm_solver... | test convergence of tf-mxne solver . | train | false |
5,007 | @contextmanager
def inside_dir(dirpath):
old_path = os.getcwd()
try:
os.chdir(dirpath)
(yield)
finally:
os.chdir(old_path)
| [
"@",
"contextmanager",
"def",
"inside_dir",
"(",
"dirpath",
")",
":",
"old_path",
"=",
"os",
".",
"getcwd",
"(",
")",
"try",
":",
"os",
".",
"chdir",
"(",
"dirpath",
")",
"(",
"yield",
")",
"finally",
":",
"os",
".",
"chdir",
"(",
"old_path",
")"
] | execute code from inside the given directory . | train | false |
5,008 | def find_ndk_project_root(source):
ndk_directory = os.path.abspath(source)
while (ndk_directory != '/'):
if os.path.exists(os.path.join(ndk_directory, 'jni')):
break
ndk_directory = os.path.dirname(ndk_directory)
else:
return None
return ndk_directory
| [
"def",
"find_ndk_project_root",
"(",
"source",
")",
":",
"ndk_directory",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"source",
")",
"while",
"(",
"ndk_directory",
"!=",
"'/'",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"os",
".",
"path",
... | given a directory path . | train | false |
5,009 | def sdm_zero():
return []
| [
"def",
"sdm_zero",
"(",
")",
":",
"return",
"[",
"]"
] | return the zero module element . | train | false |
5,010 | def _iterate_sagittal_slices(array, limits=None):
shape = array.shape[0]
for ind in range(shape):
if (limits and (ind not in limits)):
continue
(yield (ind, array[ind, :, :]))
| [
"def",
"_iterate_sagittal_slices",
"(",
"array",
",",
"limits",
"=",
"None",
")",
":",
"shape",
"=",
"array",
".",
"shape",
"[",
"0",
"]",
"for",
"ind",
"in",
"range",
"(",
"shape",
")",
":",
"if",
"(",
"limits",
"and",
"(",
"ind",
"not",
"in",
"li... | iterate sagittal slices . | train | false |
5,011 | @hsa.jit(device=True)
def device_scan(tid, data, temp, inclusive):
lane = (tid & (_WARPSIZE - 1))
warpid = (tid >> 6)
temp[tid] = data
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
warp_scan_res = warp_scan(tid, temp, inclusive)
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
if (lane == (_WARPSIZE - 1)):
temp[warpid] = temp[tid]
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
if (warpid == 0):
warp_scan(tid, temp, True)
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
if (warpid > 0):
warp_scan_res += temp[(warpid - 1)]
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
if (tid == (temp.size - 1)):
if inclusive:
temp[0] = warp_scan_res
else:
temp[0] = (warp_scan_res + data)
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
prefixsum = temp[0]
hsa.barrier(hsa.CLK_GLOBAL_MEM_FENCE)
return (warp_scan_res, prefixsum)
| [
"@",
"hsa",
".",
"jit",
"(",
"device",
"=",
"True",
")",
"def",
"device_scan",
"(",
"tid",
",",
"data",
",",
"temp",
",",
"inclusive",
")",
":",
"lane",
"=",
"(",
"tid",
"&",
"(",
"_WARPSIZE",
"-",
"1",
")",
")",
"warpid",
"=",
"(",
"tid",
">>"... | args tid: thread id data: scalar input for tid temp: shared memory for temporary work . | train | false |
5,012 | def runWithWarningsSuppressed(suppressedWarnings, f, *a, **kw):
for (args, kwargs) in suppressedWarnings:
warnings.filterwarnings(*args, **kwargs)
addedFilters = warnings.filters[:len(suppressedWarnings)]
try:
result = f(*a, **kw)
except:
exc_info = sys.exc_info()
_resetWarningFilters(None, addedFilters)
raise exc_info[0], exc_info[1], exc_info[2]
else:
if isinstance(result, defer.Deferred):
result.addBoth(_resetWarningFilters, addedFilters)
else:
_resetWarningFilters(None, addedFilters)
return result
| [
"def",
"runWithWarningsSuppressed",
"(",
"suppressedWarnings",
",",
"f",
",",
"*",
"a",
",",
"**",
"kw",
")",
":",
"for",
"(",
"args",
",",
"kwargs",
")",
"in",
"suppressedWarnings",
":",
"warnings",
".",
"filterwarnings",
"(",
"*",
"args",
",",
"**",
"k... | run c{f} . | train | false |
5,013 | def _val_or_dict(tk, options, *args):
options = _format_optdict(options)
res = tk.call(*(args + options))
if (len(options) % 2):
return res
return _dict_from_tcltuple(tk.splitlist(res))
| [
"def",
"_val_or_dict",
"(",
"tk",
",",
"options",
",",
"*",
"args",
")",
":",
"options",
"=",
"_format_optdict",
"(",
"options",
")",
"res",
"=",
"tk",
".",
"call",
"(",
"*",
"(",
"args",
"+",
"options",
")",
")",
"if",
"(",
"len",
"(",
"options",
... | format options then call func with args and options and return the appropriate result . | train | false |
5,014 | def add_or_update_given_trace_db(trace_db, action_executions=None, rules=None, trigger_instances=None):
if (trace_db is None):
raise ValueError('trace_db should be non-None.')
if (not action_executions):
action_executions = []
action_executions = [_to_trace_component_db(component=action_execution) for action_execution in action_executions]
if (not rules):
rules = []
rules = [_to_trace_component_db(component=rule) for rule in rules]
if (not trigger_instances):
trigger_instances = []
trigger_instances = [_to_trace_component_db(component=trigger_instance) for trigger_instance in trigger_instances]
if trace_db.id:
return Trace.push_components(trace_db, action_executions=action_executions, rules=rules, trigger_instances=trigger_instances)
trace_db.action_executions = action_executions
trace_db.rules = rules
trace_db.trigger_instances = trigger_instances
return Trace.add_or_update(trace_db)
| [
"def",
"add_or_update_given_trace_db",
"(",
"trace_db",
",",
"action_executions",
"=",
"None",
",",
"rules",
"=",
"None",
",",
"trigger_instances",
"=",
"None",
")",
":",
"if",
"(",
"trace_db",
"is",
"None",
")",
":",
"raise",
"ValueError",
"(",
"'trace_db sho... | will update an existing trace . | train | false |
5,015 | def wait_for_download_folder():
while (not cfg.download_dir.test_path()):
logging.debug('Waiting for "incomplete" folder')
time.sleep(2.0)
| [
"def",
"wait_for_download_folder",
"(",
")",
":",
"while",
"(",
"not",
"cfg",
".",
"download_dir",
".",
"test_path",
"(",
")",
")",
":",
"logging",
".",
"debug",
"(",
"'Waiting for \"incomplete\" folder'",
")",
"time",
".",
"sleep",
"(",
"2.0",
")"
] | wait for download folder to become available . | train | false |
5,017 | def add_checks(actions):
if (FETCH in actions):
actions.setdefault(CHECK_FETCH, [True])
if (EXTRACT in actions):
actions.setdefault(CHECK_EXTRACT, [True])
| [
"def",
"add_checks",
"(",
"actions",
")",
":",
"if",
"(",
"FETCH",
"in",
"actions",
")",
":",
"actions",
".",
"setdefault",
"(",
"CHECK_FETCH",
",",
"[",
"True",
"]",
")",
"if",
"(",
"EXTRACT",
"in",
"actions",
")",
":",
"actions",
".",
"setdefault",
... | adds appropriate checks to a given dict of actions . | train | false |
5,019 | def _ros_sort(df, observations, censorship, warn=False):
censored = sort_values(df[df[censorship]], observations, axis=0)
uncensored = sort_values(df[(~ df[censorship])], observations, axis=0)
if (censored[observations].max() > uncensored[observations].max()):
censored = censored[(censored[observations] <= uncensored[observations].max())]
if warn:
msg = 'Dropping censored observations greater than the max uncensored observation.'
warnings.warn(msg)
return censored.append(uncensored)[[observations, censorship]].reset_index(drop=True)
| [
"def",
"_ros_sort",
"(",
"df",
",",
"observations",
",",
"censorship",
",",
"warn",
"=",
"False",
")",
":",
"censored",
"=",
"sort_values",
"(",
"df",
"[",
"df",
"[",
"censorship",
"]",
"]",
",",
"observations",
",",
"axis",
"=",
"0",
")",
"uncensored"... | this function prepares a dataframe for ros . | train | false |
5,020 | def as_string(value):
if six.PY2:
buffer_types = (buffer, memoryview)
else:
buffer_types = memoryview
if (value is None):
return u''
elif isinstance(value, buffer_types):
return bytes(value).decode('utf-8', 'ignore')
elif isinstance(value, bytes):
return value.decode('utf-8', 'ignore')
else:
return six.text_type(value)
| [
"def",
"as_string",
"(",
"value",
")",
":",
"if",
"six",
".",
"PY2",
":",
"buffer_types",
"=",
"(",
"buffer",
",",
"memoryview",
")",
"else",
":",
"buffer_types",
"=",
"memoryview",
"if",
"(",
"value",
"is",
"None",
")",
":",
"return",
"u''",
"elif",
... | convert a value to a unicode object for matching with a query . | train | true |
5,021 | def _get_eth_link(vif, ifc_num):
link_id = vif.get('devname')
if (not link_id):
link_id = ('interface%d' % ifc_num)
if (vif.get('type') == 'ethernet'):
nic_type = 'phy'
else:
nic_type = vif.get('type')
link = {'id': link_id, 'vif_id': vif['id'], 'type': nic_type, 'mtu': vif['network']['meta'].get('mtu'), 'ethernet_mac_address': vif.get('address')}
return link
| [
"def",
"_get_eth_link",
"(",
"vif",
",",
"ifc_num",
")",
":",
"link_id",
"=",
"vif",
".",
"get",
"(",
"'devname'",
")",
"if",
"(",
"not",
"link_id",
")",
":",
"link_id",
"=",
"(",
"'interface%d'",
"%",
"ifc_num",
")",
"if",
"(",
"vif",
".",
"get",
... | get a vif or physical nic representation . | train | false |
5,022 | def is_valid_hidden_service_address(entry):
try:
return bool(HS_ADDRESS_PATTERN.match(entry))
except TypeError:
return False
| [
"def",
"is_valid_hidden_service_address",
"(",
"entry",
")",
":",
"try",
":",
"return",
"bool",
"(",
"HS_ADDRESS_PATTERN",
".",
"match",
"(",
"entry",
")",
")",
"except",
"TypeError",
":",
"return",
"False"
] | checks if a string is a valid format for being a hidden service address . | train | false |
5,023 | @receiver(job_was_approved)
def on_job_was_approved(sender, job, approving_user, **kwargs):
send_job_review_message(job, approving_user, 'jobs/email/job_was_approved_subject.txt', 'jobs/email/job_was_approved.txt')
| [
"@",
"receiver",
"(",
"job_was_approved",
")",
"def",
"on_job_was_approved",
"(",
"sender",
",",
"job",
",",
"approving_user",
",",
"**",
"kwargs",
")",
":",
"send_job_review_message",
"(",
"job",
",",
"approving_user",
",",
"'jobs/email/job_was_approved_subject.txt'"... | handle approving job offer . | train | false |
5,024 | def find_gui_and_backend(gui=None, gui_select=None):
import matplotlib
if (gui and (gui != 'auto')):
backend = backends[gui]
if (gui == 'agg'):
gui = None
else:
backend = matplotlib.rcParamsOrig['backend']
gui = backend2gui.get(backend, None)
if (gui_select and (gui != gui_select)):
gui = gui_select
backend = backends[gui]
return (gui, backend)
| [
"def",
"find_gui_and_backend",
"(",
"gui",
"=",
"None",
",",
"gui_select",
"=",
"None",
")",
":",
"import",
"matplotlib",
"if",
"(",
"gui",
"and",
"(",
"gui",
"!=",
"'auto'",
")",
")",
":",
"backend",
"=",
"backends",
"[",
"gui",
"]",
"if",
"(",
"gui... | given a gui string return the gui and mpl backend . | train | false |
5,026 | @register.filter
def all_ancestors_are_published(page, language):
page = page.parent
while page:
if (not page.is_published(language)):
return False
page = page.parent
return True
| [
"@",
"register",
".",
"filter",
"def",
"all_ancestors_are_published",
"(",
"page",
",",
"language",
")",
":",
"page",
"=",
"page",
".",
"parent",
"while",
"page",
":",
"if",
"(",
"not",
"page",
".",
"is_published",
"(",
"language",
")",
")",
":",
"return... | returns false if any of the ancestors of page are unpublished . | train | false |
5,027 | def generate_adjlist(G, delimiter=' '):
directed = G.is_directed()
seen = set()
for (s, nbrs) in G.adjacency():
line = (make_str(s) + delimiter)
for (t, data) in nbrs.items():
if ((not directed) and (t in seen)):
continue
if G.is_multigraph():
for d in data.values():
line += (make_str(t) + delimiter)
else:
line += (make_str(t) + delimiter)
if (not directed):
seen.add(s)
(yield line[:(- len(delimiter))])
| [
"def",
"generate_adjlist",
"(",
"G",
",",
"delimiter",
"=",
"' '",
")",
":",
"directed",
"=",
"G",
".",
"is_directed",
"(",
")",
"seen",
"=",
"set",
"(",
")",
"for",
"(",
"s",
",",
"nbrs",
")",
"in",
"G",
".",
"adjacency",
"(",
")",
":",
"line",
... | generate a single line of the graph g in adjacency list format . | train | false |
5,028 | def grains_refresh():
DETAILS['grains_cache'] = {}
return grains()
| [
"def",
"grains_refresh",
"(",
")",
":",
"DETAILS",
"[",
"'grains_cache'",
"]",
"=",
"{",
"}",
"return",
"grains",
"(",
")"
] | refresh the grains from the proxy device . | train | false |
5,029 | def simulate_noise_evoked(evoked, cov, iir_filter=None, random_state=None):
noise = evoked.copy()
noise.data = _generate_noise(evoked.info, cov, iir_filter, random_state, evoked.data.shape[1])[0]
return noise
| [
"def",
"simulate_noise_evoked",
"(",
"evoked",
",",
"cov",
",",
"iir_filter",
"=",
"None",
",",
"random_state",
"=",
"None",
")",
":",
"noise",
"=",
"evoked",
".",
"copy",
"(",
")",
"noise",
".",
"data",
"=",
"_generate_noise",
"(",
"evoked",
".",
"info"... | create noise as a multivariate gaussian . | train | false |
5,030 | def username():
global _username
if (not _username):
uid = os.getuid()
_username = (pwd_from_uid(uid)[0] or ('user%d' % uid))
return _username
| [
"def",
"username",
"(",
")",
":",
"global",
"_username",
"if",
"(",
"not",
"_username",
")",
":",
"uid",
"=",
"os",
".",
"getuid",
"(",
")",
"_username",
"=",
"(",
"pwd_from_uid",
"(",
"uid",
")",
"[",
"0",
"]",
"or",
"(",
"'user%d'",
"%",
"uid",
... | check that the username leads to an existing player . | train | false |
5,031 | def normalize_slice(s):
(start, stop, step) = (s.start, s.stop, s.step)
if (start is None):
start = 0
if (step is None):
step = 1
if ((start < 0) or (step < 0) or ((stop is not None) and (stop < 0))):
raise NotImplementedError()
return slice(start, stop, step)
| [
"def",
"normalize_slice",
"(",
"s",
")",
":",
"(",
"start",
",",
"stop",
",",
"step",
")",
"=",
"(",
"s",
".",
"start",
",",
"s",
".",
"stop",
",",
"s",
".",
"step",
")",
"if",
"(",
"start",
"is",
"None",
")",
":",
"start",
"=",
"0",
"if",
... | replace nones in slices with integers . | train | false |
5,032 | def get_attrib_file(path, size):
attribs = []
path = os.path.join(path, ATTRIB_FILE)
try:
f = open(path, 'r')
except:
return [None for unused in xrange(size)]
for unused in xrange(size):
line = f.readline().strip('\r\n ')
if line:
if (line.lower() == 'none'):
line = None
try:
line = int(line)
except:
pass
attribs.append(line)
else:
attribs.append(None)
f.close()
return attribs
| [
"def",
"get_attrib_file",
"(",
"path",
",",
"size",
")",
":",
"attribs",
"=",
"[",
"]",
"path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"ATTRIB_FILE",
")",
"try",
":",
"f",
"=",
"open",
"(",
"path",
",",
"'r'",
")",
"except",
":",
... | read jobs attributes from file . | train | false |
5,033 | def regexp2pattern(string):
if (type(string) is REGEXP_T):
flags = string.flags
string = string.pattern
if string.startswith('^'):
string = string[1:]
else:
string = ('.*' + string)
if string.endswith('$'):
string = string[:(-1)]
else:
string += '.*'
return (string, flags)
else:
return (re.escape(string), 0)
| [
"def",
"regexp2pattern",
"(",
"string",
")",
":",
"if",
"(",
"type",
"(",
"string",
")",
"is",
"REGEXP_T",
")",
":",
"flags",
"=",
"string",
".",
"flags",
"string",
"=",
"string",
".",
"pattern",
"if",
"string",
".",
"startswith",
"(",
"'^'",
")",
":... | this function takes a regexp or a string and returns a pattern and some flags . | train | false |
5,034 | def relevant_issues(issues, after):
logging.info('finding relevant issues after {}...'.format(after))
seen = set()
for issue in issues:
if (relevent_issue(issue, after) and (issue['title'] not in seen)):
seen.add(issue['title'])
(yield issue)
| [
"def",
"relevant_issues",
"(",
"issues",
",",
"after",
")",
":",
"logging",
".",
"info",
"(",
"'finding relevant issues after {}...'",
".",
"format",
"(",
"after",
")",
")",
"seen",
"=",
"set",
"(",
")",
"for",
"issue",
"in",
"issues",
":",
"if",
"(",
"r... | yields relevant closed issues given a list of issues . | train | true |
5,036 | def write_index(group):
return (u'%s_%s' % (settings.ES_INDEX_PREFIX, settings.ES_WRITE_INDEXES[group]))
| [
"def",
"write_index",
"(",
"group",
")",
":",
"return",
"(",
"u'%s_%s'",
"%",
"(",
"settings",
".",
"ES_INDEX_PREFIX",
",",
"settings",
".",
"ES_WRITE_INDEXES",
"[",
"group",
"]",
")",
")"
] | write an index file . | train | false |
5,037 | def determine_disk_image_type(image_meta):
if (not image_meta.obj_attr_is_set('disk_format')):
return None
disk_format_map = {'ami': ImageType.DISK, 'aki': ImageType.KERNEL, 'ari': ImageType.RAMDISK, 'raw': ImageType.DISK_RAW, 'vhd': ImageType.DISK_VHD, 'iso': ImageType.DISK_ISO}
try:
image_type = disk_format_map[image_meta.disk_format]
except KeyError:
raise exception.InvalidDiskFormat(disk_format=image_meta.disk_format)
LOG.debug('Detected %(type)s format for image %(image)s', {'type': ImageType.to_string(image_type), 'image': image_meta})
return image_type
| [
"def",
"determine_disk_image_type",
"(",
"image_meta",
")",
":",
"if",
"(",
"not",
"image_meta",
".",
"obj_attr_is_set",
"(",
"'disk_format'",
")",
")",
":",
"return",
"None",
"disk_format_map",
"=",
"{",
"'ami'",
":",
"ImageType",
".",
"DISK",
",",
"'aki'",
... | disk image types are used to determine where the kernel will reside within an image . | train | false |
5,041 | def test_tie_situation():
clf1 = LogisticRegression(random_state=123)
clf2 = RandomForestClassifier(random_state=123)
eclf = VotingClassifier(estimators=[('lr', clf1), ('rf', clf2)], voting='hard')
assert_equal(clf1.fit(X, y).predict(X)[73], 2)
assert_equal(clf2.fit(X, y).predict(X)[73], 1)
assert_equal(eclf.fit(X, y).predict(X)[73], 1)
| [
"def",
"test_tie_situation",
"(",
")",
":",
"clf1",
"=",
"LogisticRegression",
"(",
"random_state",
"=",
"123",
")",
"clf2",
"=",
"RandomForestClassifier",
"(",
"random_state",
"=",
"123",
")",
"eclf",
"=",
"VotingClassifier",
"(",
"estimators",
"=",
"[",
"(",... | check voting classifier selects smaller class label in tie situation . | train | false |
5,042 | def merge_pr(num):
pr = gh_api.get_pull_request(gh_project, num)
repo = pr['head']['repo']['clone_url']
branch = pr['head']['ref']
mergeable = merge_branch(repo=repo, branch=branch)
if (not mergeable):
cmd = ((('git pull ' + repo) + ' ') + branch)
not_merged[str(num)] = cmd
print '=============================================================================='
print 'Something went wrong merging this branch, you can try it manually by runngin :'
print cmd
print '=============================================================================='
| [
"def",
"merge_pr",
"(",
"num",
")",
":",
"pr",
"=",
"gh_api",
".",
"get_pull_request",
"(",
"gh_project",
",",
"num",
")",
"repo",
"=",
"pr",
"[",
"'head'",
"]",
"[",
"'repo'",
"]",
"[",
"'clone_url'",
"]",
"branch",
"=",
"pr",
"[",
"'head'",
"]",
... | try to merge the branch of pr num into current branch . | train | false |
5,043 | def verify_challenge(uri):
while True:
try:
resp = urlopen(uri)
challenge_status = json.loads(resp.read().decode('utf8'))
except IOError as e:
raise ValueError('Error checking challenge: {0} {1}'.format(e.code, json.loads(e.read().decode('utf8'))))
if (challenge_status['status'] == 'pending'):
time.sleep(2)
elif (challenge_status['status'] == 'valid'):
LOGGER.info('Domain verified!')
break
else:
raise ValueError('Domain challenge did not pass: {0}'.format(challenge_status))
| [
"def",
"verify_challenge",
"(",
"uri",
")",
":",
"while",
"True",
":",
"try",
":",
"resp",
"=",
"urlopen",
"(",
"uri",
")",
"challenge_status",
"=",
"json",
".",
"loads",
"(",
"resp",
".",
"read",
"(",
")",
".",
"decode",
"(",
"'utf8'",
")",
")",
"... | loop until our challenge is verified . | train | true |
5,044 | def _find_option_with_arg(argv, short_opts=None, long_opts=None):
for (i, arg) in enumerate(argv):
if arg.startswith(u'-'):
if (long_opts and arg.startswith(u'--')):
(name, sep, val) = arg.partition(u'=')
if (name in long_opts):
return (val if sep else argv[(i + 1)])
if (short_opts and (arg in short_opts)):
return argv[(i + 1)]
raise KeyError(u'|'.join((short_opts or ([] + long_opts) or [])))
| [
"def",
"_find_option_with_arg",
"(",
"argv",
",",
"short_opts",
"=",
"None",
",",
"long_opts",
"=",
"None",
")",
":",
"for",
"(",
"i",
",",
"arg",
")",
"in",
"enumerate",
"(",
"argv",
")",
":",
"if",
"arg",
".",
"startswith",
"(",
"u'-'",
")",
":",
... | search argv for options specifying short and longopt alternatives . | train | false |
5,045 | def split_filename(fname):
special_extensions = [u'.nii.gz', u'.tar.gz']
pth = os.path.dirname(fname)
fname = os.path.basename(fname)
ext = None
for special_ext in special_extensions:
ext_len = len(special_ext)
if ((len(fname) > ext_len) and (fname[(- ext_len):].lower() == special_ext.lower())):
ext = fname[(- ext_len):]
fname = fname[:(- ext_len)]
break
if (not ext):
(fname, ext) = os.path.splitext(fname)
return (pth, fname, ext)
| [
"def",
"split_filename",
"(",
"fname",
")",
":",
"special_extensions",
"=",
"[",
"u'.nii.gz'",
",",
"u'.tar.gz'",
"]",
"pth",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"fname",
")",
"fname",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"fname",
")"... | extract name . | train | false |
5,046 | def poll_until(predicate, steps, sleep=None):
if (sleep is None):
sleep = time.sleep
for step in steps:
result = predicate()
if result:
return result
sleep(step)
result = predicate()
if result:
return result
raise LoopExceeded(predicate, result)
| [
"def",
"poll_until",
"(",
"predicate",
",",
"steps",
",",
"sleep",
"=",
"None",
")",
":",
"if",
"(",
"sleep",
"is",
"None",
")",
":",
"sleep",
"=",
"time",
".",
"sleep",
"for",
"step",
"in",
"steps",
":",
"result",
"=",
"predicate",
"(",
")",
"if",... | perform steps until a non-false result is returned . | train | false |
5,047 | @commands(u'suggest')
def suggest(bot, trigger):
if (not trigger.group(2)):
return bot.reply(u'No query term.')
query = trigger.group(2)
uri = u'http://websitedev.de/temp-bin/suggest.pl?q='
answer = web.get((uri + query.replace(u'+', u'%2B')))
if answer:
bot.say(answer)
else:
bot.reply(u'Sorry, no result.')
| [
"@",
"commands",
"(",
"u'suggest'",
")",
"def",
"suggest",
"(",
"bot",
",",
"trigger",
")",
":",
"if",
"(",
"not",
"trigger",
".",
"group",
"(",
"2",
")",
")",
":",
"return",
"bot",
".",
"reply",
"(",
"u'No query term.'",
")",
"query",
"=",
"trigger"... | processes translation suggestions and stores them in the database . | train | false |
5,049 | def rs_swap(a, b):
d = {}
for rsa in a:
d[rsa] = [rsb for rsb in b if (rsa.symbol == rsb.symbol)][0]
return d
| [
"def",
"rs_swap",
"(",
"a",
",",
"b",
")",
":",
"d",
"=",
"{",
"}",
"for",
"rsa",
"in",
"a",
":",
"d",
"[",
"rsa",
"]",
"=",
"[",
"rsb",
"for",
"rsb",
"in",
"b",
"if",
"(",
"rsa",
".",
"symbol",
"==",
"rsb",
".",
"symbol",
")",
"]",
"[",
... | build a dictionary to swap randomsymbols based on their underlying symbol . | train | false |
5,050 | def _check_for_int(x):
try:
y = int(x)
except (OverflowError, ValueError):
pass
else:
if ((x == x) and (y == x)):
return y
return x
| [
"def",
"_check_for_int",
"(",
"x",
")",
":",
"try",
":",
"y",
"=",
"int",
"(",
"x",
")",
"except",
"(",
"OverflowError",
",",
"ValueError",
")",
":",
"pass",
"else",
":",
"if",
"(",
"(",
"x",
"==",
"x",
")",
"and",
"(",
"y",
"==",
"x",
")",
"... | this is a compatibility function that takes a c{float} and converts it to an c{int} if the values are equal . | train | true |
5,052 | def unzipIter(filename, directory='.', overwrite=0):
zf = zipfile.ZipFile(filename, 'r')
names = zf.namelist()
if (not os.path.exists(directory)):
os.makedirs(directory)
remaining = len(zf.namelist())
for entry in names:
remaining -= 1
isdir = (zf.getinfo(entry).external_attr & DIR_BIT)
f = os.path.join(directory, entry)
if isdir:
if (not os.path.exists(f)):
os.makedirs(f)
else:
fdir = os.path.split(f)[0]
if (not os.path.exists(fdir)):
os.makedirs(fdir)
if (overwrite or (not os.path.exists(f))):
outfile = file(f, 'wb')
outfile.write(zf.read(entry))
outfile.close()
(yield remaining)
| [
"def",
"unzipIter",
"(",
"filename",
",",
"directory",
"=",
"'.'",
",",
"overwrite",
"=",
"0",
")",
":",
"zf",
"=",
"zipfile",
".",
"ZipFile",
"(",
"filename",
",",
"'r'",
")",
"names",
"=",
"zf",
".",
"namelist",
"(",
")",
"if",
"(",
"not",
"os",
... | return a generator for the zipfile . | train | false |
5,053 | def package_dirname(package):
if isinstance(package, str):
package = __import__(package, fromlist=[''])
filename = package.__file__
dirname = os.path.dirname(filename)
return dirname
| [
"def",
"package_dirname",
"(",
"package",
")",
":",
"if",
"isinstance",
"(",
"package",
",",
"str",
")",
":",
"package",
"=",
"__import__",
"(",
"package",
",",
"fromlist",
"=",
"[",
"''",
"]",
")",
"filename",
"=",
"package",
".",
"__file__",
"dirname",... | return the directory path where package is located . | train | false |
5,054 | def random_string_from_module(module):
return random.choice(string_from_module(module))
| [
"def",
"random_string_from_module",
"(",
"module",
")",
":",
"return",
"random",
".",
"choice",
"(",
"string_from_module",
"(",
"module",
")",
")"
] | returns a random global string from a module . | train | false |
5,055 | def _build_bounding_box_lookup(bounding_box_file):
lines = tf.gfile.FastGFile(bounding_box_file, 'r').readlines()
images_to_bboxes = {}
num_bbox = 0
num_image = 0
for l in lines:
if l:
parts = l.split(',')
assert (len(parts) == 5), ('Failed to parse: %s' % l)
filename = parts[0]
xmin = float(parts[1])
ymin = float(parts[2])
xmax = float(parts[3])
ymax = float(parts[4])
box = [xmin, ymin, xmax, ymax]
if (filename not in images_to_bboxes):
images_to_bboxes[filename] = []
num_image += 1
images_to_bboxes[filename].append(box)
num_bbox += 1
print(('Successfully read %d bounding boxes across %d images.' % (num_bbox, num_image)))
return images_to_bboxes
| [
"def",
"_build_bounding_box_lookup",
"(",
"bounding_box_file",
")",
":",
"lines",
"=",
"tf",
".",
"gfile",
".",
"FastGFile",
"(",
"bounding_box_file",
",",
"'r'",
")",
".",
"readlines",
"(",
")",
"images_to_bboxes",
"=",
"{",
"}",
"num_bbox",
"=",
"0",
"num_... | build a lookup from image file to bounding boxes . | train | true |
5,056 | def convert_PostalAddressProperty(model, prop, kwargs):
return get_TextField(kwargs)
| [
"def",
"convert_PostalAddressProperty",
"(",
"model",
",",
"prop",
",",
"kwargs",
")",
":",
"return",
"get_TextField",
"(",
"kwargs",
")"
] | returns a form field for a db . | train | false |
5,057 | def _flatten_artist_credit(credit):
artist_parts = []
artist_sort_parts = []
artist_credit_parts = []
for el in credit:
if isinstance(el, basestring):
artist_parts.append(el)
artist_credit_parts.append(el)
artist_sort_parts.append(el)
else:
alias = _preferred_alias(el['artist'].get('alias-list', ()))
if alias:
cur_artist_name = alias['alias']
else:
cur_artist_name = el['artist']['name']
artist_parts.append(cur_artist_name)
if alias:
artist_sort_parts.append(alias['sort-name'])
elif ('sort-name' in el['artist']):
artist_sort_parts.append(el['artist']['sort-name'])
else:
artist_sort_parts.append(cur_artist_name)
if ('name' in el):
artist_credit_parts.append(el['name'])
else:
artist_credit_parts.append(cur_artist_name)
return (''.join(artist_parts), ''.join(artist_sort_parts), ''.join(artist_credit_parts))
| [
"def",
"_flatten_artist_credit",
"(",
"credit",
")",
":",
"artist_parts",
"=",
"[",
"]",
"artist_sort_parts",
"=",
"[",
"]",
"artist_credit_parts",
"=",
"[",
"]",
"for",
"el",
"in",
"credit",
":",
"if",
"isinstance",
"(",
"el",
",",
"basestring",
")",
":",... | given a list representing an artist-credit block . | train | false |
5,058 | def adjust_string(original, length):
if (not (length > 0)):
raise AssertionError
resulting_string = original
if (len(resulting_string) > length):
unit_db = (resulting_string.endswith('dB') and (resulting_string.find('.') != (-1)))
if ((len(resulting_string.strip()) > length) and unit_db):
resulting_string = resulting_string[:(-2)]
if (len(resulting_string) > length):
for char in (' ', '_', 'i', 'o', 'u', 'e', 'a'):
offset = (0 if (char == ' ') else 1)
while ((len(resulting_string) > length) and (resulting_string.rfind(char, offset) > 0)):
char_pos = resulting_string.rfind(char, offset)
resulting_string = (resulting_string[:char_pos] + resulting_string[(char_pos + 1):])
resulting_string = resulting_string[:length]
resulting_string = ((len(resulting_string) < length) and resulting_string.ljust(length))
return resulting_string
| [
"def",
"adjust_string",
"(",
"original",
",",
"length",
")",
":",
"if",
"(",
"not",
"(",
"length",
">",
"0",
")",
")",
":",
"raise",
"AssertionError",
"resulting_string",
"=",
"original",
"if",
"(",
"len",
"(",
"resulting_string",
")",
">",
"length",
")"... | brings the string to the given length by either removing characters or adding spaces . | train | false |
5,059 | def testAgent(path, agent, port=DEFAULT_PORT):
agent = adaptAgentObject(BenchmarkingAgent(agent))
experiment = RLCExperiment(path, str(port))
experiment.start()
clientAgent = ClientAgent(agent)
clientAgent.connect(DEFAULT_HOST, port, CLIENT_TIMEOUT)
logging.info('Agent connected')
clientAgent.runAgentEventLoop()
clientAgent.close()
logging.info('Agent finished')
experiment.stop()
return agent.agent.benchmark
| [
"def",
"testAgent",
"(",
"path",
",",
"agent",
",",
"port",
"=",
"DEFAULT_PORT",
")",
":",
"agent",
"=",
"adaptAgentObject",
"(",
"BenchmarkingAgent",
"(",
"agent",
")",
")",
"experiment",
"=",
"RLCExperiment",
"(",
"path",
",",
"str",
"(",
"port",
")",
... | test an agent once on a rlcompetition experiment . | train | false |
5,060 | @np.deprecate(new_name='expm')
def expm3(A, q=20):
A = _asarray_square(A)
n = A.shape[0]
t = A.dtype.char
if (t not in ['f', 'F', 'd', 'D']):
A = A.astype('d')
t = 'd'
eA = np.identity(n, dtype=t)
trm = np.identity(n, dtype=t)
castfunc = cast[t]
for k in range(1, q):
trm[:] = (trm.dot(A) / castfunc(k))
eA += trm
return eA
| [
"@",
"np",
".",
"deprecate",
"(",
"new_name",
"=",
"'expm'",
")",
"def",
"expm3",
"(",
"A",
",",
"q",
"=",
"20",
")",
":",
"A",
"=",
"_asarray_square",
"(",
"A",
")",
"n",
"=",
"A",
".",
"shape",
"[",
"0",
"]",
"t",
"=",
"A",
".",
"dtype",
... | compute the matrix exponential using taylor series . | train | false |
5,061 | @login_required
@require_POST
def add_member(request, group_slug):
prof = get_object_or_404(GroupProfile, slug=group_slug)
if (not _user_can_edit(request.user, prof)):
raise PermissionDenied
form = AddUserForm(request.POST)
if form.is_valid():
for user in form.cleaned_data['users']:
user.groups.add(prof.group)
msg = _('{users} added to the group successfully!').format(users=request.POST.get('users'))
messages.add_message(request, messages.SUCCESS, msg)
return HttpResponseRedirect(prof.get_absolute_url())
msg = _('There were errors adding members to the group, see below.')
messages.add_message(request, messages.ERROR, msg)
return profile(request, group_slug, member_form=form)
| [
"@",
"login_required",
"@",
"require_POST",
"def",
"add_member",
"(",
"request",
",",
"group_slug",
")",
":",
"prof",
"=",
"get_object_or_404",
"(",
"GroupProfile",
",",
"slug",
"=",
"group_slug",
")",
"if",
"(",
"not",
"_user_can_edit",
"(",
"request",
".",
... | add a member to the group . | train | false |
5,062 | def isstdin():
if (not _state):
raise RuntimeError('no active input()')
return _state.isstdin()
| [
"def",
"isstdin",
"(",
")",
":",
"if",
"(",
"not",
"_state",
")",
":",
"raise",
"RuntimeError",
"(",
"'no active input()'",
")",
"return",
"_state",
".",
"isstdin",
"(",
")"
] | returns true if the last line was read from sys . | train | false |
5,063 | def files_contains(file1, file2, attributes=None):
local_file = open(file1, 'U').readlines()
history_data = open(file2, 'U').read()
lines_diff = int(attributes.get('lines_diff', 0))
line_diff_count = 0
while local_file:
contains = local_file.pop(0).rstrip('\n\r')
if (contains not in history_data):
line_diff_count += 1
if (line_diff_count > lines_diff):
raise AssertionError(("Failed to find '%s' in history data. (lines_diff=%i):\n" % (contains, lines_diff)))
| [
"def",
"files_contains",
"(",
"file1",
",",
"file2",
",",
"attributes",
"=",
"None",
")",
":",
"local_file",
"=",
"open",
"(",
"file1",
",",
"'U'",
")",
".",
"readlines",
"(",
")",
"history_data",
"=",
"open",
"(",
"file2",
",",
"'U'",
")",
".",
"rea... | check the contents of file2 for substrings found in file1 . | train | false |
5,065 | def new_post_mails(reply, users_and_watches):
post_url = add_utm(reply.get_absolute_url(), 'kbforums-post')
c = {'post': reply.content, 'post_html': reply.content_parsed, 'author': reply.creator, 'host': Site.objects.get_current().domain, 'thread': reply.thread.title, 'forum': reply.thread.document.title, 'post_url': post_url}
return emails_with_users_and_watches(subject=_lazy(u'Re: {forum} - {thread}'), text_template='kbforums/email/new_post.ltxt', html_template='kbforums/email/new_post.html', context_vars=c, users_and_watches=users_and_watches)
| [
"def",
"new_post_mails",
"(",
"reply",
",",
"users_and_watches",
")",
":",
"post_url",
"=",
"add_utm",
"(",
"reply",
".",
"get_absolute_url",
"(",
")",
",",
"'kbforums-post'",
")",
"c",
"=",
"{",
"'post'",
":",
"reply",
".",
"content",
",",
"'post_html'",
... | return an interable of emailmessages to send when a new post is created . | train | false |
5,066 | def cds():
rebulk = Rebulk().regex_defaults(flags=re.IGNORECASE, abbreviations=[dash])
rebulk.regex('cd-?(?P<cd>\\d+)(?:-?of-?(?P<cd_count>\\d+))?', validator={'cd': (lambda match: (0 < match.value < 100)), 'cd_count': (lambda match: (0 < match.value < 100))}, formatter={'cd': int, 'cd_count': int}, children=True, private_parent=True, properties={'cd': [None], 'cd_count': [None]})
rebulk.regex('(?P<cd_count>\\d+)-?cds?', validator={'cd': (lambda match: (0 < match.value < 100)), 'cd_count': (lambda match: (0 < match.value < 100))}, formatter={'cd_count': int}, children=True, private_parent=True, properties={'cd': [None], 'cd_count': [None]})
return rebulk
| [
"def",
"cds",
"(",
")",
":",
"rebulk",
"=",
"Rebulk",
"(",
")",
".",
"regex_defaults",
"(",
"flags",
"=",
"re",
".",
"IGNORECASE",
",",
"abbreviations",
"=",
"[",
"dash",
"]",
")",
"rebulk",
".",
"regex",
"(",
"'cd-?(?P<cd>\\\\d+)(?:-?of-?(?P<cd_count>\\\\d+... | builder for rebulk object . | train | false |
5,069 | def _is_single_paragraph(node):
if (len(node) == 0):
return False
elif (len(node) > 1):
for subnode in node[1:]:
if (not isinstance(subnode, nodes.system_message)):
return False
if isinstance(node[0], nodes.paragraph):
return True
return False
| [
"def",
"_is_single_paragraph",
"(",
"node",
")",
":",
"if",
"(",
"len",
"(",
"node",
")",
"==",
"0",
")",
":",
"return",
"False",
"elif",
"(",
"len",
"(",
"node",
")",
">",
"1",
")",
":",
"for",
"subnode",
"in",
"node",
"[",
"1",
":",
"]",
":",... | true if the node only contains one paragraph . | train | false |
5,074 | def dispatch_method(self, basename, arg, **options):
method_name = ('%s_%s' % (basename, arg.__class__.__name__))
if hasattr(self, method_name):
f = getattr(self, method_name)
result = f(arg, **options)
if (result is not None):
return result
raise NotImplementedError(("%s.%s can't handle: %r" % (self.__class__.__name__, basename, arg)))
| [
"def",
"dispatch_method",
"(",
"self",
",",
"basename",
",",
"arg",
",",
"**",
"options",
")",
":",
"method_name",
"=",
"(",
"'%s_%s'",
"%",
"(",
"basename",
",",
"arg",
".",
"__class__",
".",
"__name__",
")",
")",
"if",
"hasattr",
"(",
"self",
",",
... | dispatch a method to the proper handlers . | train | false |
5,075 | def convert_sysv_runlevel(level):
runlevel = str(level)
if (runlevel == '0'):
target = 'poweroff.target'
elif (runlevel in ['1', 's', 'single']):
target = 'rescue.target'
elif (runlevel in ['2', '3', '4']):
target = 'multi-user.target'
elif (runlevel == '5'):
target = 'graphical.target'
elif (runlevel == '6'):
target = 'reboot.target'
else:
raise ValueError(('unknown runlevel %s' % level))
return target
| [
"def",
"convert_sysv_runlevel",
"(",
"level",
")",
":",
"runlevel",
"=",
"str",
"(",
"level",
")",
"if",
"(",
"runlevel",
"==",
"'0'",
")",
":",
"target",
"=",
"'poweroff.target'",
"elif",
"(",
"runlevel",
"in",
"[",
"'1'",
",",
"'s'",
",",
"'single'",
... | convert runlevel to systemd target . | train | false |
5,076 | def _path_to_string(path):
return '.'.join(path)
| [
"def",
"_path_to_string",
"(",
"path",
")",
":",
"return",
"'.'",
".",
"join",
"(",
"path",
")"
] | convert a list of path elements into a single path string . | train | false |
5,077 | def argrelmax(data, axis=0, order=1, mode='clip'):
return argrelextrema(data, np.greater, axis, order, mode)
| [
"def",
"argrelmax",
"(",
"data",
",",
"axis",
"=",
"0",
",",
"order",
"=",
"1",
",",
"mode",
"=",
"'clip'",
")",
":",
"return",
"argrelextrema",
"(",
"data",
",",
"np",
".",
"greater",
",",
"axis",
",",
"order",
",",
"mode",
")"
] | calculate the relative maxima of data . | train | true |
5,078 | def min_weighted_vertex_cover(G, weight=None):
cost = dict(G.nodes(data=weight, default=1))
for (u, v) in G.edges():
min_cost = min(cost[u], cost[v])
cost[u] -= min_cost
cost[v] -= min_cost
return {u for (u, c) in cost.items() if (c == 0)}
| [
"def",
"min_weighted_vertex_cover",
"(",
"G",
",",
"weight",
"=",
"None",
")",
":",
"cost",
"=",
"dict",
"(",
"G",
".",
"nodes",
"(",
"data",
"=",
"weight",
",",
"default",
"=",
"1",
")",
")",
"for",
"(",
"u",
",",
"v",
")",
"in",
"G",
".",
"ed... | returns an approximate minimum weighted vertex cover . | train | false |
5,079 | @must_have_permission('write')
@must_not_be_registration
@must_have_addon('forward', 'node')
def forward_config_put(auth, node_addon, **kwargs):
try:
node_addon.url = request.json['url']
node_addon.label = request.json.get('label')
except (KeyError, TypeError, ValueError):
raise HTTPError(http.BAD_REQUEST)
try:
dirty_fields = node_addon.get_dirty_fields()
node_addon.save()
except ValidationValueError:
raise HTTPError(http.BAD_REQUEST)
if ('url' in dirty_fields):
node_addon.owner.add_log(action='forward_url_changed', params=dict(node=node_addon.owner._id, project=node_addon.owner.parent_id, forward_url=node_addon.url), auth=auth, save=True)
return {}
| [
"@",
"must_have_permission",
"(",
"'write'",
")",
"@",
"must_not_be_registration",
"@",
"must_have_addon",
"(",
"'forward'",
",",
"'node'",
")",
"def",
"forward_config_put",
"(",
"auth",
",",
"node_addon",
",",
"**",
"kwargs",
")",
":",
"try",
":",
"node_addon",... | set configuration for forward node settings . | train | false |
5,080 | def stem_text(text):
text = utils.to_unicode(text)
p = PorterStemmer()
return ' '.join((p.stem(word) for word in text.split()))
| [
"def",
"stem_text",
"(",
"text",
")",
":",
"text",
"=",
"utils",
".",
"to_unicode",
"(",
"text",
")",
"p",
"=",
"PorterStemmer",
"(",
")",
"return",
"' '",
".",
"join",
"(",
"(",
"p",
".",
"stem",
"(",
"word",
")",
"for",
"word",
"in",
"text",
".... | return lowercase and stemmed version of string text . | train | false |
5,082 | def profile_func(filename=None):
def proffunc(fun):
def profiled_func(*args, **kwargs):
logging.info('Profiling function {0}'.format(fun.__name__))
try:
profiler = cProfile.Profile()
retval = profiler.runcall(fun, *args, **kwargs)
profiler.dump_stats((filename or '{0}_func.profile'.format(fun.__name__)))
except IOError:
logging.exception('Could not open profile file {0}'.format(filename))
return retval
return profiled_func
return proffunc
| [
"def",
"profile_func",
"(",
"filename",
"=",
"None",
")",
":",
"def",
"proffunc",
"(",
"fun",
")",
":",
"def",
"profiled_func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"logging",
".",
"info",
"(",
"'Profiling function {0}'",
".",
"format",
"(",
... | decorator for adding profiling to a nested function in salt . | train | true |
5,087 | def getTranslateTetragrid(elementNode, prefix):
translation = getCumulativeVector3Remove(Vector3(), elementNode, prefix)
if translation.getIsDefault():
return None
return getTranslateTetragridByTranslation(translation)
| [
"def",
"getTranslateTetragrid",
"(",
"elementNode",
",",
"prefix",
")",
":",
"translation",
"=",
"getCumulativeVector3Remove",
"(",
"Vector3",
"(",
")",
",",
"elementNode",
",",
"prefix",
")",
"if",
"translation",
".",
"getIsDefault",
"(",
")",
":",
"return",
... | get translate matrix and delete the translate attributes . | train | false |
5,088 | def unsafe_inline_enabled(response):
non_report_only_policies = retrieve_csp_policies(response)
report_only_policies = retrieve_csp_policies(response, True)
policies_all = merge_policies_dict(non_report_only_policies, report_only_policies)
if (len(policies_all) > 0):
for directive_name in policies_all:
if ((directive_name.lower() != CSP_DIRECTIVE_SCRIPT) and (directive_name.lower() != CSP_DIRECTIVE_STYLE)):
continue
for directive_value in policies_all[directive_name]:
if (directive_value.strip().lower() == CSP_DIRECTIVE_VALUE_UNSAFE_INLINE):
return True
return False
| [
"def",
"unsafe_inline_enabled",
"(",
"response",
")",
":",
"non_report_only_policies",
"=",
"retrieve_csp_policies",
"(",
"response",
")",
"report_only_policies",
"=",
"retrieve_csp_policies",
"(",
"response",
",",
"True",
")",
"policies_all",
"=",
"merge_policies_dict",
... | method to detect if csp policies are specified for script/style . | train | false |
5,089 | def norm_dlldy(y):
return (- y)
| [
"def",
"norm_dlldy",
"(",
"y",
")",
":",
"return",
"(",
"-",
"y",
")"
] | derivative of log pdf of standard normal with respect to y . | train | false |
5,090 | def isfloat(x):
try:
a = float(x)
except ValueError:
return False
else:
return True
| [
"def",
"isfloat",
"(",
"x",
")",
":",
"try",
":",
"a",
"=",
"float",
"(",
"x",
")",
"except",
"ValueError",
":",
"return",
"False",
"else",
":",
"return",
"True"
] | check if argument is float . | train | false |
5,092 | @transaction.atomic
def mass_get_or_create(model_class, base_queryset, id_field, default_dict, global_defaults):
current_instances = list(base_queryset)
current_ids = set([unicode(getattr(c, id_field)) for c in current_instances])
given_ids = map(unicode, default_dict.keys())
new_ids = [g for g in given_ids if (g not in current_ids)]
prepared_models = []
for new_id in new_ids:
defaults = default_dict[new_id]
defaults[id_field] = new_id
defaults.update(global_defaults)
model_instance = model_class(**defaults)
prepared_models.append(model_instance)
if hasattr(model_class.objects, 'bulk_create'):
model_class.objects.bulk_create(prepared_models)
else:
[m.save() for m in prepared_models]
inserted_model_instances = prepared_models
return (current_instances, inserted_model_instances)
| [
"@",
"transaction",
".",
"atomic",
"def",
"mass_get_or_create",
"(",
"model_class",
",",
"base_queryset",
",",
"id_field",
",",
"default_dict",
",",
"global_defaults",
")",
":",
"current_instances",
"=",
"list",
"(",
"base_queryset",
")",
"current_ids",
"=",
"set"... | updates the data by inserting all not found records doesnt delete records if not in the new data example usage . | train | false |
5,093 | def decode_utf8(string):
if isinstance(string, str):
for encoding in (('utf-8',), ('windows-1252',), ('utf-8', 'ignore')):
try:
return string.decode(*encoding)
except:
pass
return string
return unicode(string)
| [
"def",
"decode_utf8",
"(",
"string",
")",
":",
"if",
"isinstance",
"(",
"string",
",",
"str",
")",
":",
"for",
"encoding",
"in",
"(",
"(",
"'utf-8'",
",",
")",
",",
"(",
"'windows-1252'",
",",
")",
",",
"(",
"'utf-8'",
",",
"'ignore'",
")",
")",
":... | returns the given string as a unicode string . | train | false |
5,097 | def add_callers(target, source):
new_callers = {}
for (func, caller) in target.iteritems():
new_callers[func] = caller
for (func, caller) in source.iteritems():
if (func in new_callers):
new_callers[func] = tuple([(i[0] + i[1]) for i in zip(caller, new_callers[func])])
else:
new_callers[func] = caller
return new_callers
| [
"def",
"add_callers",
"(",
"target",
",",
"source",
")",
":",
"new_callers",
"=",
"{",
"}",
"for",
"(",
"func",
",",
"caller",
")",
"in",
"target",
".",
"iteritems",
"(",
")",
":",
"new_callers",
"[",
"func",
"]",
"=",
"caller",
"for",
"(",
"func",
... | combine two caller lists in a single list . | train | false |
5,098 | def _strip_cache_events(data, opts):
event_data = copy.deepcopy(data)
strip_fields = opts.get('cache_event_strip_fields', [])
for field in strip_fields:
if (field in event_data):
del event_data[field]
return event_data
| [
"def",
"_strip_cache_events",
"(",
"data",
",",
"opts",
")",
":",
"event_data",
"=",
"copy",
".",
"deepcopy",
"(",
"data",
")",
"strip_fields",
"=",
"opts",
".",
"get",
"(",
"'cache_event_strip_fields'",
",",
"[",
"]",
")",
"for",
"field",
"in",
"strip_fie... | strip out user-configured sensitive event data . | train | true |
5,099 | def _compute_node_to_inventory_dict(compute_node):
result = {}
if (compute_node.vcpus > 0):
result[VCPU] = {'total': compute_node.vcpus, 'reserved': 0, 'min_unit': 1, 'max_unit': compute_node.vcpus, 'step_size': 1, 'allocation_ratio': compute_node.cpu_allocation_ratio}
if (compute_node.memory_mb > 0):
result[MEMORY_MB] = {'total': compute_node.memory_mb, 'reserved': CONF.reserved_host_memory_mb, 'min_unit': 1, 'max_unit': compute_node.memory_mb, 'step_size': 1, 'allocation_ratio': compute_node.ram_allocation_ratio}
if (compute_node.local_gb > 0):
result[DISK_GB] = {'total': compute_node.local_gb, 'reserved': (CONF.reserved_host_disk_mb * 1024), 'min_unit': 1, 'max_unit': compute_node.local_gb, 'step_size': 1, 'allocation_ratio': compute_node.disk_allocation_ratio}
return result
| [
"def",
"_compute_node_to_inventory_dict",
"(",
"compute_node",
")",
":",
"result",
"=",
"{",
"}",
"if",
"(",
"compute_node",
".",
"vcpus",
">",
"0",
")",
":",
"result",
"[",
"VCPU",
"]",
"=",
"{",
"'total'",
":",
"compute_node",
".",
"vcpus",
",",
"'rese... | given a supplied objects . | train | false |
5,100 | def docs_up_to_date(path):
if (hasattr(sys, 'frozen') or (not is_git_repo())):
return True
html_path = os.path.join(qutebrowser.basedir, 'html', 'doc', path)
filename = os.path.splitext(path)[0]
asciidoc_path = os.path.join(qutebrowser.basedir, os.path.pardir, 'doc', 'help', (filename + '.asciidoc'))
try:
html_time = os.path.getmtime(html_path)
asciidoc_time = os.path.getmtime(asciidoc_path)
except FileNotFoundError:
return True
return (asciidoc_time <= html_time)
| [
"def",
"docs_up_to_date",
"(",
"path",
")",
":",
"if",
"(",
"hasattr",
"(",
"sys",
",",
"'frozen'",
")",
"or",
"(",
"not",
"is_git_repo",
"(",
")",
")",
")",
":",
"return",
"True",
"html_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"qutebrowser",... | check if the generated html documentation is up to date . | train | false |
5,101 | def __determine_list_kwargs(options):
list_kwargs = __determine_delete_kwargs(options)
list_kwargs.update(__kwargs_option_to_dict(options.list_kwargs))
return list_kwargs
| [
"def",
"__determine_list_kwargs",
"(",
"options",
")",
":",
"list_kwargs",
"=",
"__determine_delete_kwargs",
"(",
"options",
")",
"list_kwargs",
".",
"update",
"(",
"__kwargs_option_to_dict",
"(",
"options",
".",
"list_kwargs",
")",
")",
"return",
"list_kwargs"
] | determine the standard keyword arguments to pass to list() method . | train | false |
5,103 | def _kb_readout(request, readout_slug, readouts, locale=None, mode=None, product=None):
if (readout_slug not in readouts):
raise Http404
return readouts[readout_slug](request, locale=locale, mode=mode, product=product)
| [
"def",
"_kb_readout",
"(",
"request",
",",
"readout_slug",
",",
"readouts",
",",
"locale",
"=",
"None",
",",
"mode",
"=",
"None",
",",
"product",
"=",
"None",
")",
":",
"if",
"(",
"readout_slug",
"not",
"in",
"readouts",
")",
":",
"raise",
"Http404",
"... | instantiate and return the readout with the given slug . | train | false |
5,104 | def MergeGlobalXcodeSettingsToSpec(global_dict, spec):
global_xcode_settings = global_dict.get('xcode_settings', {})
for config in spec['configurations'].values():
if ('xcode_settings' in config):
new_settings = global_xcode_settings.copy()
new_settings.update(config['xcode_settings'])
config['xcode_settings'] = new_settings
| [
"def",
"MergeGlobalXcodeSettingsToSpec",
"(",
"global_dict",
",",
"spec",
")",
":",
"global_xcode_settings",
"=",
"global_dict",
".",
"get",
"(",
"'xcode_settings'",
",",
"{",
"}",
")",
"for",
"config",
"in",
"spec",
"[",
"'configurations'",
"]",
".",
"values",
... | merges the global xcode_settings dictionary into each configuration of the target represented by spec . | train | false |
5,105 | def serialize_field(value):
if isinstance(value, basestring):
return value
return json.dumps(value, cls=EdxJSONEncoder)
| [
"def",
"serialize_field",
"(",
"value",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"basestring",
")",
":",
"return",
"value",
"return",
"json",
".",
"dumps",
"(",
"value",
",",
"cls",
"=",
"EdxJSONEncoder",
")"
] | return a string version of the value . | train | false |
5,106 | def _rec_eval_in(g, a, v, i, j, K):
if (i == j):
return dmp_eval(g, a, v, K)
(v, i) = ((v - 1), (i + 1))
return dmp_strip([_rec_eval_in(c, a, v, i, j, K) for c in g], v)
| [
"def",
"_rec_eval_in",
"(",
"g",
",",
"a",
",",
"v",
",",
"i",
",",
"j",
",",
"K",
")",
":",
"if",
"(",
"i",
"==",
"j",
")",
":",
"return",
"dmp_eval",
"(",
"g",
",",
"a",
",",
"v",
",",
"K",
")",
"(",
"v",
",",
"i",
")",
"=",
"(",
"(... | recursive helper for :func:dmp_eval_in . | train | false |
5,107 | def getSharedFace(firstEdge, faces, secondEdge):
for firstEdgeFaceIndex in firstEdge.faceIndexes:
for secondEdgeFaceIndex in secondEdge.faceIndexes:
if (firstEdgeFaceIndex == secondEdgeFaceIndex):
return faces[firstEdgeFaceIndex]
return None
| [
"def",
"getSharedFace",
"(",
"firstEdge",
",",
"faces",
",",
"secondEdge",
")",
":",
"for",
"firstEdgeFaceIndex",
"in",
"firstEdge",
".",
"faceIndexes",
":",
"for",
"secondEdgeFaceIndex",
"in",
"secondEdge",
".",
"faceIndexes",
":",
"if",
"(",
"firstEdgeFaceIndex"... | get the face which is shared by two edges . | train | false |
5,108 | def deflate_long(n, add_sign_padding=True):
s = bytes()
n = long(n)
while ((n != 0) and (n != (-1))):
s = (struct.pack('>I', (n & xffffffff)) + s)
n >>= 32
for i in enumerate(s):
if ((n == 0) and (i[1] != deflate_zero)):
break
if ((n == (-1)) and (i[1] != deflate_ff)):
break
else:
i = (0,)
if (n == 0):
s = zero_byte
else:
s = max_byte
s = s[i[0]:]
if add_sign_padding:
if ((n == 0) and (byte_ord(s[0]) >= 128)):
s = (zero_byte + s)
if ((n == (-1)) and (byte_ord(s[0]) < 128)):
s = (max_byte + s)
return s
| [
"def",
"deflate_long",
"(",
"n",
",",
"add_sign_padding",
"=",
"True",
")",
":",
"s",
"=",
"bytes",
"(",
")",
"n",
"=",
"long",
"(",
"n",
")",
"while",
"(",
"(",
"n",
"!=",
"0",
")",
"and",
"(",
"n",
"!=",
"(",
"-",
"1",
")",
")",
")",
":",... | turns a long-int into a normalized byte string . | train | true |
5,109 | def promoted_param(registry, xml_parent, data):
pdef = base_param(registry, xml_parent, data, False, 'hudson.plugins.promoted__builds.parameters.PromotedBuildParameterDefinition')
try:
XML.SubElement(pdef, 'projectName').text = data['project-name']
except KeyError:
raise MissingAttributeError('project-name')
XML.SubElement(pdef, 'promotionProcessName').text = data.get('promotion-name', None)
| [
"def",
"promoted_param",
"(",
"registry",
",",
"xml_parent",
",",
"data",
")",
":",
"pdef",
"=",
"base_param",
"(",
"registry",
",",
"xml_parent",
",",
"data",
",",
"False",
",",
"'hudson.plugins.promoted__builds.parameters.PromotedBuildParameterDefinition'",
")",
"tr... | yaml: promoted build a promoted build parameter . | train | false |
5,110 | def snapshot_in_progress(client, repository=None, snapshot=None):
allsnaps = get_snapshot_data(client, repository=repository)
inprogress = [snap['snapshot'] for snap in allsnaps if (('state' in snap.keys()) and (snap['state'] == 'IN_PROGRESS'))]
if snapshot:
return (snapshot if (snapshot in inprogress) else False)
elif (len(inprogress) == 0):
return False
elif (len(inprogress) == 1):
return inprogress[0]
else:
raise CuratorException('More than 1 snapshot in progress: {0}'.format(inprogress))
| [
"def",
"snapshot_in_progress",
"(",
"client",
",",
"repository",
"=",
"None",
",",
"snapshot",
"=",
"None",
")",
":",
"allsnaps",
"=",
"get_snapshot_data",
"(",
"client",
",",
"repository",
"=",
"repository",
")",
"inprogress",
"=",
"[",
"snap",
"[",
"'snaps... | determine whether the provided snapshot in repository is in_progress . | train | false |
5,111 | def discovery_agent(rpyc_port):
data = struct.pack('<H', rpyc_port)
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.bind(('', UDP_DISCOVERY_PORT))
log('discovery_agent: started')
while True:
(query, addr) = s.recvfrom(MAX_DGRAM_SIZE)
if (query == QUERY_MAGIC):
log('discovery_agent: now answering', addr)
s.sendto(data, addr)
| [
"def",
"discovery_agent",
"(",
"rpyc_port",
")",
":",
"data",
"=",
"struct",
".",
"pack",
"(",
"'<H'",
",",
"rpyc_port",
")",
"s",
"=",
"socket",
".",
"socket",
"(",
"socket",
".",
"AF_INET",
",",
"socket",
".",
"SOCK_DGRAM",
")",
"s",
".",
"bind",
"... | answers broadcasted queries with the port of the rpyc server on this machine . | train | false |
5,113 | def consistencygroup_destroy(context, consistencygroup_id):
return IMPL.consistencygroup_destroy(context, consistencygroup_id)
| [
"def",
"consistencygroup_destroy",
"(",
"context",
",",
"consistencygroup_id",
")",
":",
"return",
"IMPL",
".",
"consistencygroup_destroy",
"(",
"context",
",",
"consistencygroup_id",
")"
] | destroy the consistencygroup or raise if it does not exist . | train | false |
5,115 | def obedient_process(*args, **kwargs):
stopped = []
def handler(sig, frame):
send('SIGINT')
stopped.append(1)
signal.signal(signal.SIGINT, handler)
send('STARTED')
while (not stopped):
signal.pause()
send('STOPPED')
| [
"def",
"obedient_process",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"stopped",
"=",
"[",
"]",
"def",
"handler",
"(",
"sig",
",",
"frame",
")",
":",
"send",
"(",
"'SIGINT'",
")",
"stopped",
".",
"append",
"(",
"1",
")",
"signal",
".",
"signa... | waits for sigint and exits normally . | train | false |
5,116 | def startswith_(a, fragment, msg=None):
assert a.startswith(fragment), (msg or ('%r does not start with %r' % (a, fragment)))
| [
"def",
"startswith_",
"(",
"a",
",",
"fragment",
",",
"msg",
"=",
"None",
")",
":",
"assert",
"a",
".",
"startswith",
"(",
"fragment",
")",
",",
"(",
"msg",
"or",
"(",
"'%r does not start with %r'",
"%",
"(",
"a",
",",
"fragment",
")",
")",
")"
] | assert a . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.