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 |
|---|---|---|---|---|---|
13,941
|
@docfiller
def gaussian_laplace(input, sigma, output=None, mode='reflect', cval=0.0, **kwargs):
input = numpy.asarray(input)
def derivative2(input, axis, output, mode, cval, sigma, **kwargs):
order = ([0] * input.ndim)
order[axis] = 2
return gaussian_filter(input, sigma, order, output, mode, cval, **kwargs)
return generic_laplace(input, derivative2, output, mode, cval, extra_arguments=(sigma,), extra_keywords=kwargs)
|
[
"@",
"docfiller",
"def",
"gaussian_laplace",
"(",
"input",
",",
"sigma",
",",
"output",
"=",
"None",
",",
"mode",
"=",
"'reflect'",
",",
"cval",
"=",
"0.0",
",",
"**",
"kwargs",
")",
":",
"input",
"=",
"numpy",
".",
"asarray",
"(",
"input",
")",
"def",
"derivative2",
"(",
"input",
",",
"axis",
",",
"output",
",",
"mode",
",",
"cval",
",",
"sigma",
",",
"**",
"kwargs",
")",
":",
"order",
"=",
"(",
"[",
"0",
"]",
"*",
"input",
".",
"ndim",
")",
"order",
"[",
"axis",
"]",
"=",
"2",
"return",
"gaussian_filter",
"(",
"input",
",",
"sigma",
",",
"order",
",",
"output",
",",
"mode",
",",
"cval",
",",
"**",
"kwargs",
")",
"return",
"generic_laplace",
"(",
"input",
",",
"derivative2",
",",
"output",
",",
"mode",
",",
"cval",
",",
"extra_arguments",
"=",
"(",
"sigma",
",",
")",
",",
"extra_keywords",
"=",
"kwargs",
")"
] |
multidimensional laplace filter using gaussian second derivatives .
|
train
| false
|
13,942
|
def test_client_options(config):
if config['use_ssl']:
if (('certificate' in config) and config['certificate']):
read_file(config['certificate'])
if (('client_cert' in config) and config['client_cert']):
read_file(config['client_cert'])
if (('client_key' in config) and config['client_key']):
read_file(config['client_key'])
|
[
"def",
"test_client_options",
"(",
"config",
")",
":",
"if",
"config",
"[",
"'use_ssl'",
"]",
":",
"if",
"(",
"(",
"'certificate'",
"in",
"config",
")",
"and",
"config",
"[",
"'certificate'",
"]",
")",
":",
"read_file",
"(",
"config",
"[",
"'certificate'",
"]",
")",
"if",
"(",
"(",
"'client_cert'",
"in",
"config",
")",
"and",
"config",
"[",
"'client_cert'",
"]",
")",
":",
"read_file",
"(",
"config",
"[",
"'client_cert'",
"]",
")",
"if",
"(",
"(",
"'client_key'",
"in",
"config",
")",
"and",
"config",
"[",
"'client_key'",
"]",
")",
":",
"read_file",
"(",
"config",
"[",
"'client_key'",
"]",
")"
] |
test whether a ssl/tls files exist .
|
train
| false
|
13,943
|
def dmp_trial_division(f, factors, u, K):
result = []
for factor in factors:
k = 0
while True:
(q, r) = dmp_div(f, factor, u, K)
if dmp_zero_p(r, u):
(f, k) = (q, (k + 1))
else:
break
result.append((factor, k))
return _sort_factors(result)
|
[
"def",
"dmp_trial_division",
"(",
"f",
",",
"factors",
",",
"u",
",",
"K",
")",
":",
"result",
"=",
"[",
"]",
"for",
"factor",
"in",
"factors",
":",
"k",
"=",
"0",
"while",
"True",
":",
"(",
"q",
",",
"r",
")",
"=",
"dmp_div",
"(",
"f",
",",
"factor",
",",
"u",
",",
"K",
")",
"if",
"dmp_zero_p",
"(",
"r",
",",
"u",
")",
":",
"(",
"f",
",",
"k",
")",
"=",
"(",
"q",
",",
"(",
"k",
"+",
"1",
")",
")",
"else",
":",
"break",
"result",
".",
"append",
"(",
"(",
"factor",
",",
"k",
")",
")",
"return",
"_sort_factors",
"(",
"result",
")"
] |
determine multiplicities of factors using trial division .
|
train
| false
|
13,945
|
def load_svmlight_file(f, n_features=None, dtype=np.float64, multilabel=False, zero_based='auto', query_id=False):
return tuple(load_svmlight_files([f], n_features, dtype, multilabel, zero_based, query_id))
|
[
"def",
"load_svmlight_file",
"(",
"f",
",",
"n_features",
"=",
"None",
",",
"dtype",
"=",
"np",
".",
"float64",
",",
"multilabel",
"=",
"False",
",",
"zero_based",
"=",
"'auto'",
",",
"query_id",
"=",
"False",
")",
":",
"return",
"tuple",
"(",
"load_svmlight_files",
"(",
"[",
"f",
"]",
",",
"n_features",
",",
"dtype",
",",
"multilabel",
",",
"zero_based",
",",
"query_id",
")",
")"
] |
load datasets in the svmlight / libsvm format into sparse csr matrix this format is a text-based format .
|
train
| false
|
13,947
|
@overload(np.trace)
def matrix_trace_impl(a, offset=types.int_):
_check_linalg_matrix(a, 'trace', la_prefix=False)
if (not isinstance(offset, types.Integer)):
raise TypeError(('integer argument expected, got %s' % offset))
def matrix_trace_impl(a, offset=0):
(rows, cols) = a.shape
k = offset
if (k < 0):
rows = (rows + k)
if (k > 0):
cols = (cols - k)
n = max(min(rows, cols), 0)
ret = 0
if (k >= 0):
for i in range(n):
ret += a[(i, (k + i))]
else:
for i in range(n):
ret += a[((i - k), i)]
return ret
return matrix_trace_impl
|
[
"@",
"overload",
"(",
"np",
".",
"trace",
")",
"def",
"matrix_trace_impl",
"(",
"a",
",",
"offset",
"=",
"types",
".",
"int_",
")",
":",
"_check_linalg_matrix",
"(",
"a",
",",
"'trace'",
",",
"la_prefix",
"=",
"False",
")",
"if",
"(",
"not",
"isinstance",
"(",
"offset",
",",
"types",
".",
"Integer",
")",
")",
":",
"raise",
"TypeError",
"(",
"(",
"'integer argument expected, got %s'",
"%",
"offset",
")",
")",
"def",
"matrix_trace_impl",
"(",
"a",
",",
"offset",
"=",
"0",
")",
":",
"(",
"rows",
",",
"cols",
")",
"=",
"a",
".",
"shape",
"k",
"=",
"offset",
"if",
"(",
"k",
"<",
"0",
")",
":",
"rows",
"=",
"(",
"rows",
"+",
"k",
")",
"if",
"(",
"k",
">",
"0",
")",
":",
"cols",
"=",
"(",
"cols",
"-",
"k",
")",
"n",
"=",
"max",
"(",
"min",
"(",
"rows",
",",
"cols",
")",
",",
"0",
")",
"ret",
"=",
"0",
"if",
"(",
"k",
">=",
"0",
")",
":",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"ret",
"+=",
"a",
"[",
"(",
"i",
",",
"(",
"k",
"+",
"i",
")",
")",
"]",
"else",
":",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"ret",
"+=",
"a",
"[",
"(",
"(",
"i",
"-",
"k",
")",
",",
"i",
")",
"]",
"return",
"ret",
"return",
"matrix_trace_impl"
] |
computes the trace of an array .
|
train
| false
|
13,948
|
def getsavefilename(parent=None, caption='', basedir='', filters='', selectedfilter='', options=None):
return _qfiledialog_wrapper('getSaveFileName', parent=parent, caption=caption, basedir=basedir, filters=filters, selectedfilter=selectedfilter, options=options)
|
[
"def",
"getsavefilename",
"(",
"parent",
"=",
"None",
",",
"caption",
"=",
"''",
",",
"basedir",
"=",
"''",
",",
"filters",
"=",
"''",
",",
"selectedfilter",
"=",
"''",
",",
"options",
"=",
"None",
")",
":",
"return",
"_qfiledialog_wrapper",
"(",
"'getSaveFileName'",
",",
"parent",
"=",
"parent",
",",
"caption",
"=",
"caption",
",",
"basedir",
"=",
"basedir",
",",
"filters",
"=",
"filters",
",",
"selectedfilter",
"=",
"selectedfilter",
",",
"options",
"=",
"options",
")"
] |
wrapper around qtgui .
|
train
| true
|
13,949
|
def enable_theming():
if hasattr(settings, 'COMPREHENSIVE_THEME_DIR'):
logger.warning('\x1b[93m \nDeprecated: \n DCTB COMPREHENSIVE_THEME_DIR setting has been deprecated in favor of COMPREHENSIVE_THEME_DIRS.\x1b[00m')
for theme in get_themes():
if (theme.themes_base_dir not in settings.MAKO_TEMPLATES['main']):
settings.MAKO_TEMPLATES['main'].insert(0, theme.themes_base_dir)
_add_theming_locales()
|
[
"def",
"enable_theming",
"(",
")",
":",
"if",
"hasattr",
"(",
"settings",
",",
"'COMPREHENSIVE_THEME_DIR'",
")",
":",
"logger",
".",
"warning",
"(",
"'\\x1b[93m \\nDeprecated: \\n DCTB COMPREHENSIVE_THEME_DIR setting has been deprecated in favor of COMPREHENSIVE_THEME_DIRS.\\x1b[00m'",
")",
"for",
"theme",
"in",
"get_themes",
"(",
")",
":",
"if",
"(",
"theme",
".",
"themes_base_dir",
"not",
"in",
"settings",
".",
"MAKO_TEMPLATES",
"[",
"'main'",
"]",
")",
":",
"settings",
".",
"MAKO_TEMPLATES",
"[",
"'main'",
"]",
".",
"insert",
"(",
"0",
",",
"theme",
".",
"themes_base_dir",
")",
"_add_theming_locales",
"(",
")"
] |
add directories and relevant paths to settings for comprehensive theming .
|
train
| false
|
13,950
|
def wiki_to_html(wiki_markup, locale=settings.WIKI_DEFAULT_LANGUAGE, nofollow=True):
return WikiParser().parse(wiki_markup, show_toc=False, locale=locale, nofollow=nofollow)
|
[
"def",
"wiki_to_html",
"(",
"wiki_markup",
",",
"locale",
"=",
"settings",
".",
"WIKI_DEFAULT_LANGUAGE",
",",
"nofollow",
"=",
"True",
")",
":",
"return",
"WikiParser",
"(",
")",
".",
"parse",
"(",
"wiki_markup",
",",
"show_toc",
"=",
"False",
",",
"locale",
"=",
"locale",
",",
"nofollow",
"=",
"nofollow",
")"
] |
wiki markup -> html jinja2 .
|
train
| false
|
13,952
|
@logit
def addition_func(x):
return (x + x)
|
[
"@",
"logit",
"def",
"addition_func",
"(",
"x",
")",
":",
"return",
"(",
"x",
"+",
"x",
")"
] |
do some math .
|
train
| false
|
13,953
|
def test_hsl_to_rgb_part_16():
assert (hsl_to_rgb(180, 100, 0) == (0, 0, 0))
assert (hsl_to_rgb(180, 100, 10) == (0, 51, 51))
assert (hsl_to_rgb(180, 100, 20) == (0, 102, 102))
assert (hsl_to_rgb(180, 100, 30) == (0, 153, 153))
assert (hsl_to_rgb(180, 100, 40) == (0, 204, 204))
assert (hsl_to_rgb(180, 100, 50) == (0, 255, 255))
assert (hsl_to_rgb(180, 100, 60) == (51, 255, 255))
assert (hsl_to_rgb(180, 100, 70) == (102, 255, 255))
assert (hsl_to_rgb(180, 100, 80) == (153, 255, 255))
assert (hsl_to_rgb(180, 100, 90) == (204, 255, 255))
assert (hsl_to_rgb(180, 100, 100) == (255, 255, 255))
|
[
"def",
"test_hsl_to_rgb_part_16",
"(",
")",
":",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"0",
")",
"==",
"(",
"0",
",",
"0",
",",
"0",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"10",
")",
"==",
"(",
"0",
",",
"51",
",",
"51",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"20",
")",
"==",
"(",
"0",
",",
"102",
",",
"102",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"30",
")",
"==",
"(",
"0",
",",
"153",
",",
"153",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"40",
")",
"==",
"(",
"0",
",",
"204",
",",
"204",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"50",
")",
"==",
"(",
"0",
",",
"255",
",",
"255",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"60",
")",
"==",
"(",
"51",
",",
"255",
",",
"255",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"70",
")",
"==",
"(",
"102",
",",
"255",
",",
"255",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"80",
")",
"==",
"(",
"153",
",",
"255",
",",
"255",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"90",
")",
"==",
"(",
"204",
",",
"255",
",",
"255",
")",
")",
"assert",
"(",
"hsl_to_rgb",
"(",
"180",
",",
"100",
",",
"100",
")",
"==",
"(",
"255",
",",
"255",
",",
"255",
")",
")"
] |
test hsl to rgb color function .
|
train
| false
|
13,954
|
def platform_encode(p):
if isinstance(p, str):
try:
return p.decode('utf-8')
except:
return p.decode(codepage, errors='replace').replace('?', '!')
else:
return p
|
[
"def",
"platform_encode",
"(",
"p",
")",
":",
"if",
"isinstance",
"(",
"p",
",",
"str",
")",
":",
"try",
":",
"return",
"p",
".",
"decode",
"(",
"'utf-8'",
")",
"except",
":",
"return",
"p",
".",
"decode",
"(",
"codepage",
",",
"errors",
"=",
"'replace'",
")",
".",
"replace",
"(",
"'?'",
",",
"'!'",
")",
"else",
":",
"return",
"p"
] |
return unicode name .
|
train
| false
|
13,956
|
def assignCrowdingDist(individuals):
if (len(individuals) == 0):
return
distances = ([0.0] * len(individuals))
crowd = [(ind.fitness.values, i) for (i, ind) in enumerate(individuals)]
nobj = len(individuals[0].fitness.values)
for i in xrange(nobj):
crowd.sort(key=(lambda element: element[0][i]))
distances[crowd[0][1]] = float('inf')
distances[crowd[(-1)][1]] = float('inf')
if (crowd[(-1)][0][i] == crowd[0][0][i]):
continue
norm = (nobj * float((crowd[(-1)][0][i] - crowd[0][0][i])))
for (prev, cur, next) in zip(crowd[:(-2)], crowd[1:(-1)], crowd[2:]):
distances[cur[1]] += ((next[0][i] - prev[0][i]) / norm)
for (i, dist) in enumerate(distances):
individuals[i].fitness.crowding_dist = dist
|
[
"def",
"assignCrowdingDist",
"(",
"individuals",
")",
":",
"if",
"(",
"len",
"(",
"individuals",
")",
"==",
"0",
")",
":",
"return",
"distances",
"=",
"(",
"[",
"0.0",
"]",
"*",
"len",
"(",
"individuals",
")",
")",
"crowd",
"=",
"[",
"(",
"ind",
".",
"fitness",
".",
"values",
",",
"i",
")",
"for",
"(",
"i",
",",
"ind",
")",
"in",
"enumerate",
"(",
"individuals",
")",
"]",
"nobj",
"=",
"len",
"(",
"individuals",
"[",
"0",
"]",
".",
"fitness",
".",
"values",
")",
"for",
"i",
"in",
"xrange",
"(",
"nobj",
")",
":",
"crowd",
".",
"sort",
"(",
"key",
"=",
"(",
"lambda",
"element",
":",
"element",
"[",
"0",
"]",
"[",
"i",
"]",
")",
")",
"distances",
"[",
"crowd",
"[",
"0",
"]",
"[",
"1",
"]",
"]",
"=",
"float",
"(",
"'inf'",
")",
"distances",
"[",
"crowd",
"[",
"(",
"-",
"1",
")",
"]",
"[",
"1",
"]",
"]",
"=",
"float",
"(",
"'inf'",
")",
"if",
"(",
"crowd",
"[",
"(",
"-",
"1",
")",
"]",
"[",
"0",
"]",
"[",
"i",
"]",
"==",
"crowd",
"[",
"0",
"]",
"[",
"0",
"]",
"[",
"i",
"]",
")",
":",
"continue",
"norm",
"=",
"(",
"nobj",
"*",
"float",
"(",
"(",
"crowd",
"[",
"(",
"-",
"1",
")",
"]",
"[",
"0",
"]",
"[",
"i",
"]",
"-",
"crowd",
"[",
"0",
"]",
"[",
"0",
"]",
"[",
"i",
"]",
")",
")",
")",
"for",
"(",
"prev",
",",
"cur",
",",
"next",
")",
"in",
"zip",
"(",
"crowd",
"[",
":",
"(",
"-",
"2",
")",
"]",
",",
"crowd",
"[",
"1",
":",
"(",
"-",
"1",
")",
"]",
",",
"crowd",
"[",
"2",
":",
"]",
")",
":",
"distances",
"[",
"cur",
"[",
"1",
"]",
"]",
"+=",
"(",
"(",
"next",
"[",
"0",
"]",
"[",
"i",
"]",
"-",
"prev",
"[",
"0",
"]",
"[",
"i",
"]",
")",
"/",
"norm",
")",
"for",
"(",
"i",
",",
"dist",
")",
"in",
"enumerate",
"(",
"distances",
")",
":",
"individuals",
"[",
"i",
"]",
".",
"fitness",
".",
"crowding_dist",
"=",
"dist"
] |
assign a crowding distance to each individuals fitness .
|
train
| false
|
13,957
|
def get_max_memberships_for_project(project):
if (project.owner is None):
return None
if project.is_private:
return project.owner.max_memberships_private_projects
return project.owner.max_memberships_public_projects
|
[
"def",
"get_max_memberships_for_project",
"(",
"project",
")",
":",
"if",
"(",
"project",
".",
"owner",
"is",
"None",
")",
":",
"return",
"None",
"if",
"project",
".",
"is_private",
":",
"return",
"project",
".",
"owner",
".",
"max_memberships_private_projects",
"return",
"project",
".",
"owner",
".",
"max_memberships_public_projects"
] |
return tha maximun of membersh for a concrete project .
|
train
| false
|
13,958
|
def _get_next_name(names, name):
indexes = [int(a.group(2)) for x in names for a in re.finditer('(^{} \\()(\\d{{1,}})(\\)$)'.format(name), x)]
if ((name not in names) and (not indexes)):
return name
return '{} ({})'.format(name, (max(indexes, default=1) + 1))
|
[
"def",
"_get_next_name",
"(",
"names",
",",
"name",
")",
":",
"indexes",
"=",
"[",
"int",
"(",
"a",
".",
"group",
"(",
"2",
")",
")",
"for",
"x",
"in",
"names",
"for",
"a",
"in",
"re",
".",
"finditer",
"(",
"'(^{} \\\\()(\\\\d{{1,}})(\\\\)$)'",
".",
"format",
"(",
"name",
")",
",",
"x",
")",
"]",
"if",
"(",
"(",
"name",
"not",
"in",
"names",
")",
"and",
"(",
"not",
"indexes",
")",
")",
":",
"return",
"name",
"return",
"'{} ({})'",
".",
"format",
"(",
"name",
",",
"(",
"max",
"(",
"indexes",
",",
"default",
"=",
"1",
")",
"+",
"1",
")",
")"
] |
returns next possible attribute name .
|
train
| false
|
13,960
|
def _rewrite_saxena_1(fac, po, g, x):
(_, s) = _get_coeff_exp(po, x)
(a, b) = _get_coeff_exp(g.argument, x)
period = g.get_period()
a = _my_principal_branch(a, period)
C = (fac / (abs(b) * (a ** (((s + 1) / b) - 1))))
def tr(l):
return [((a + ((1 + s) / b)) - 1) for a in l]
return (C, meijerg(tr(g.an), tr(g.aother), tr(g.bm), tr(g.bother), (a * x)))
|
[
"def",
"_rewrite_saxena_1",
"(",
"fac",
",",
"po",
",",
"g",
",",
"x",
")",
":",
"(",
"_",
",",
"s",
")",
"=",
"_get_coeff_exp",
"(",
"po",
",",
"x",
")",
"(",
"a",
",",
"b",
")",
"=",
"_get_coeff_exp",
"(",
"g",
".",
"argument",
",",
"x",
")",
"period",
"=",
"g",
".",
"get_period",
"(",
")",
"a",
"=",
"_my_principal_branch",
"(",
"a",
",",
"period",
")",
"C",
"=",
"(",
"fac",
"/",
"(",
"abs",
"(",
"b",
")",
"*",
"(",
"a",
"**",
"(",
"(",
"(",
"s",
"+",
"1",
")",
"/",
"b",
")",
"-",
"1",
")",
")",
")",
")",
"def",
"tr",
"(",
"l",
")",
":",
"return",
"[",
"(",
"(",
"a",
"+",
"(",
"(",
"1",
"+",
"s",
")",
"/",
"b",
")",
")",
"-",
"1",
")",
"for",
"a",
"in",
"l",
"]",
"return",
"(",
"C",
",",
"meijerg",
"(",
"tr",
"(",
"g",
".",
"an",
")",
",",
"tr",
"(",
"g",
".",
"aother",
")",
",",
"tr",
"(",
"g",
".",
"bm",
")",
",",
"tr",
"(",
"g",
".",
"bother",
")",
",",
"(",
"a",
"*",
"x",
")",
")",
")"
] |
rewrite the integral fac*po*g dx .
|
train
| false
|
13,961
|
def normalizeNewline(text):
text = text.replace('\r\n', '\n')
text = text.replace('\r', '\n')
return NEWLINES_REGEX.sub('\n', text)
|
[
"def",
"normalizeNewline",
"(",
"text",
")",
":",
"text",
"=",
"text",
".",
"replace",
"(",
"'\\r\\n'",
",",
"'\\n'",
")",
"text",
"=",
"text",
".",
"replace",
"(",
"'\\r'",
",",
"'\\n'",
")",
"return",
"NEWLINES_REGEX",
".",
"sub",
"(",
"'\\n'",
",",
"text",
")"
] |
replace windows and mac newlines with unix newlines .
|
train
| false
|
13,963
|
@click.command(u'new-site')
@click.argument(u'site')
@click.option(u'--db-name', help=u'Database name')
@click.option(u'--mariadb-root-username', default=u'root', help=u'Root username for MariaDB')
@click.option(u'--mariadb-root-password', help=u'Root password for MariaDB')
@click.option(u'--admin-password', help=u'Administrator password for new site', default=None)
@click.option(u'--verbose', is_flag=True, default=False, help=u'Verbose')
@click.option(u'--force', help=u'Force restore if site/database already exists', is_flag=True, default=False)
@click.option(u'--source_sql', help=u'Initiate database with a SQL file')
@click.option(u'--install-app', multiple=True, help=u'Install app after installation')
def new_site(site, mariadb_root_username=None, mariadb_root_password=None, admin_password=None, verbose=False, install_apps=None, source_sql=None, force=None, install_app=None, db_name=None):
frappe.init(site=site, new_site=True)
_new_site(db_name, site, mariadb_root_username=mariadb_root_username, mariadb_root_password=mariadb_root_password, admin_password=admin_password, verbose=verbose, install_apps=install_app, source_sql=source_sql, force=force)
if (len(frappe.utils.get_sites()) == 1):
use(site)
|
[
"@",
"click",
".",
"command",
"(",
"u'new-site'",
")",
"@",
"click",
".",
"argument",
"(",
"u'site'",
")",
"@",
"click",
".",
"option",
"(",
"u'--db-name'",
",",
"help",
"=",
"u'Database name'",
")",
"@",
"click",
".",
"option",
"(",
"u'--mariadb-root-username'",
",",
"default",
"=",
"u'root'",
",",
"help",
"=",
"u'Root username for MariaDB'",
")",
"@",
"click",
".",
"option",
"(",
"u'--mariadb-root-password'",
",",
"help",
"=",
"u'Root password for MariaDB'",
")",
"@",
"click",
".",
"option",
"(",
"u'--admin-password'",
",",
"help",
"=",
"u'Administrator password for new site'",
",",
"default",
"=",
"None",
")",
"@",
"click",
".",
"option",
"(",
"u'--verbose'",
",",
"is_flag",
"=",
"True",
",",
"default",
"=",
"False",
",",
"help",
"=",
"u'Verbose'",
")",
"@",
"click",
".",
"option",
"(",
"u'--force'",
",",
"help",
"=",
"u'Force restore if site/database already exists'",
",",
"is_flag",
"=",
"True",
",",
"default",
"=",
"False",
")",
"@",
"click",
".",
"option",
"(",
"u'--source_sql'",
",",
"help",
"=",
"u'Initiate database with a SQL file'",
")",
"@",
"click",
".",
"option",
"(",
"u'--install-app'",
",",
"multiple",
"=",
"True",
",",
"help",
"=",
"u'Install app after installation'",
")",
"def",
"new_site",
"(",
"site",
",",
"mariadb_root_username",
"=",
"None",
",",
"mariadb_root_password",
"=",
"None",
",",
"admin_password",
"=",
"None",
",",
"verbose",
"=",
"False",
",",
"install_apps",
"=",
"None",
",",
"source_sql",
"=",
"None",
",",
"force",
"=",
"None",
",",
"install_app",
"=",
"None",
",",
"db_name",
"=",
"None",
")",
":",
"frappe",
".",
"init",
"(",
"site",
"=",
"site",
",",
"new_site",
"=",
"True",
")",
"_new_site",
"(",
"db_name",
",",
"site",
",",
"mariadb_root_username",
"=",
"mariadb_root_username",
",",
"mariadb_root_password",
"=",
"mariadb_root_password",
",",
"admin_password",
"=",
"admin_password",
",",
"verbose",
"=",
"verbose",
",",
"install_apps",
"=",
"install_app",
",",
"source_sql",
"=",
"source_sql",
",",
"force",
"=",
"force",
")",
"if",
"(",
"len",
"(",
"frappe",
".",
"utils",
".",
"get_sites",
"(",
")",
")",
"==",
"1",
")",
":",
"use",
"(",
"site",
")"
] |
create a new site in the bench .
|
train
| false
|
13,964
|
def kernel_integrity(attrs=None, where=None):
if (__grains__['os_family'] in ['RedHat', 'Debian']):
return _osquery_cmd(table='kernel_integrity', attrs=attrs, where=where)
return {'result': False, 'comment': 'Only available on Red Hat or Debian based systems.'}
|
[
"def",
"kernel_integrity",
"(",
"attrs",
"=",
"None",
",",
"where",
"=",
"None",
")",
":",
"if",
"(",
"__grains__",
"[",
"'os_family'",
"]",
"in",
"[",
"'RedHat'",
",",
"'Debian'",
"]",
")",
":",
"return",
"_osquery_cmd",
"(",
"table",
"=",
"'kernel_integrity'",
",",
"attrs",
"=",
"attrs",
",",
"where",
"=",
"where",
")",
"return",
"{",
"'result'",
":",
"False",
",",
"'comment'",
":",
"'Only available on Red Hat or Debian based systems.'",
"}"
] |
return kernel_integrity information from osquery cli example: .
|
train
| true
|
13,965
|
@frappe.whitelist()
def install_app(name):
frappe.only_for(u'System Manager')
if (name not in frappe.get_all_apps(True)):
if (not frappe.conf.disallow_app_listing):
get_app(name)
frappe.cache().delete_value([u'app_hooks'])
import site
reload(site)
else:
frappe.throw(u'Listing app not allowed')
app_hooks = frappe.get_hooks(app_name=name)
if app_hooks.get(u'hide_in_installer'):
frappe.throw(_(u'You cannot install this app'))
enqueue(u'frappe.desk.page.applications.applications.start_install', name=name)
frappe.msgprint(_(u'Queued for install'))
|
[
"@",
"frappe",
".",
"whitelist",
"(",
")",
"def",
"install_app",
"(",
"name",
")",
":",
"frappe",
".",
"only_for",
"(",
"u'System Manager'",
")",
"if",
"(",
"name",
"not",
"in",
"frappe",
".",
"get_all_apps",
"(",
"True",
")",
")",
":",
"if",
"(",
"not",
"frappe",
".",
"conf",
".",
"disallow_app_listing",
")",
":",
"get_app",
"(",
"name",
")",
"frappe",
".",
"cache",
"(",
")",
".",
"delete_value",
"(",
"[",
"u'app_hooks'",
"]",
")",
"import",
"site",
"reload",
"(",
"site",
")",
"else",
":",
"frappe",
".",
"throw",
"(",
"u'Listing app not allowed'",
")",
"app_hooks",
"=",
"frappe",
".",
"get_hooks",
"(",
"app_name",
"=",
"name",
")",
"if",
"app_hooks",
".",
"get",
"(",
"u'hide_in_installer'",
")",
":",
"frappe",
".",
"throw",
"(",
"_",
"(",
"u'You cannot install this app'",
")",
")",
"enqueue",
"(",
"u'frappe.desk.page.applications.applications.start_install'",
",",
"name",
"=",
"name",
")",
"frappe",
".",
"msgprint",
"(",
"_",
"(",
"u'Queued for install'",
")",
")"
] |
install a new app to site .
|
train
| false
|
13,967
|
def convert_time(time, result_format='number', exclude_millis=False):
return Time(time).convert(result_format, millis=is_falsy(exclude_millis))
|
[
"def",
"convert_time",
"(",
"time",
",",
"result_format",
"=",
"'number'",
",",
"exclude_millis",
"=",
"False",
")",
":",
"return",
"Time",
"(",
"time",
")",
".",
"convert",
"(",
"result_format",
",",
"millis",
"=",
"is_falsy",
"(",
"exclude_millis",
")",
")"
] |
convert a time in seconds into the biggest unit .
|
train
| false
|
13,968
|
def AmericanDateToEpoch(date_str):
try:
epoch = time.strptime(date_str, '%m/%d/%Y')
return (int(calendar.timegm(epoch)) * 1000000)
except ValueError:
return 0
|
[
"def",
"AmericanDateToEpoch",
"(",
"date_str",
")",
":",
"try",
":",
"epoch",
"=",
"time",
".",
"strptime",
"(",
"date_str",
",",
"'%m/%d/%Y'",
")",
"return",
"(",
"int",
"(",
"calendar",
".",
"timegm",
"(",
"epoch",
")",
")",
"*",
"1000000",
")",
"except",
"ValueError",
":",
"return",
"0"
] |
take a us format date and return epoch .
|
train
| true
|
13,970
|
@_held_figure
def delaunay_plot_2d(tri, ax=None):
if (tri.points.shape[1] != 2):
raise ValueError('Delaunay triangulation is not 2-D')
ax.plot(tri.points[:, 0], tri.points[:, 1], 'o')
ax.triplot(tri.points[:, 0], tri.points[:, 1], tri.simplices.copy())
_adjust_bounds(ax, tri.points)
return ax.figure
|
[
"@",
"_held_figure",
"def",
"delaunay_plot_2d",
"(",
"tri",
",",
"ax",
"=",
"None",
")",
":",
"if",
"(",
"tri",
".",
"points",
".",
"shape",
"[",
"1",
"]",
"!=",
"2",
")",
":",
"raise",
"ValueError",
"(",
"'Delaunay triangulation is not 2-D'",
")",
"ax",
".",
"plot",
"(",
"tri",
".",
"points",
"[",
":",
",",
"0",
"]",
",",
"tri",
".",
"points",
"[",
":",
",",
"1",
"]",
",",
"'o'",
")",
"ax",
".",
"triplot",
"(",
"tri",
".",
"points",
"[",
":",
",",
"0",
"]",
",",
"tri",
".",
"points",
"[",
":",
",",
"1",
"]",
",",
"tri",
".",
"simplices",
".",
"copy",
"(",
")",
")",
"_adjust_bounds",
"(",
"ax",
",",
"tri",
".",
"points",
")",
"return",
"ax",
".",
"figure"
] |
plot the given delaunay triangulation in 2-d parameters tri : scipy .
|
train
| false
|
13,971
|
def test_scenario_ptbr_from_string():
ptbr = Language('pt-br')
scenario = Scenario.from_string(SCENARIO, language=ptbr)
assert_equals(scenario.name, u'Consolidar o banco de dados de cursos universit\xe1rios em arquivo texto')
assert_equals(scenario.steps[0].hashes, [{'Nome': u'Ci\xeancia da Computa\xe7\xe3o', u'Dura\xe7\xe3o': '5 anos'}, {'Nome': u'Nutri\xe7\xe3o', u'Dura\xe7\xe3o': '4 anos'}])
|
[
"def",
"test_scenario_ptbr_from_string",
"(",
")",
":",
"ptbr",
"=",
"Language",
"(",
"'pt-br'",
")",
"scenario",
"=",
"Scenario",
".",
"from_string",
"(",
"SCENARIO",
",",
"language",
"=",
"ptbr",
")",
"assert_equals",
"(",
"scenario",
".",
"name",
",",
"u'Consolidar o banco de dados de cursos universit\\xe1rios em arquivo texto'",
")",
"assert_equals",
"(",
"scenario",
".",
"steps",
"[",
"0",
"]",
".",
"hashes",
",",
"[",
"{",
"'Nome'",
":",
"u'Ci\\xeancia da Computa\\xe7\\xe3o'",
",",
"u'Dura\\xe7\\xe3o'",
":",
"'5 anos'",
"}",
",",
"{",
"'Nome'",
":",
"u'Nutri\\xe7\\xe3o'",
",",
"u'Dura\\xe7\\xe3o'",
":",
"'4 anos'",
"}",
"]",
")"
] |
language: pt-br -> scenario .
|
train
| false
|
13,972
|
def get_class_from_str(class_path):
(module_path, klass_name) = class_path.rsplit(u'.', 1)
module = import_module(module_path)
return getattr(module, klass_name)
|
[
"def",
"get_class_from_str",
"(",
"class_path",
")",
":",
"(",
"module_path",
",",
"klass_name",
")",
"=",
"class_path",
".",
"rsplit",
"(",
"u'.'",
",",
"1",
")",
"module",
"=",
"import_module",
"(",
"module_path",
")",
"return",
"getattr",
"(",
"module",
",",
"klass_name",
")"
] |
dynamically load a view class from a string path "myapp .
|
train
| false
|
13,973
|
def test_float_range():
assert (0.5 == float_range('0.5'))
|
[
"def",
"test_float_range",
"(",
")",
":",
"assert",
"(",
"0.5",
"==",
"float_range",
"(",
"'0.5'",
")",
")"
] |
assert that the tpot cli interfaces float range returns a float with input is in 0 .
|
train
| false
|
13,974
|
def floating_ip_deallocate(context, address):
return IMPL.floating_ip_deallocate(context, address)
|
[
"def",
"floating_ip_deallocate",
"(",
"context",
",",
"address",
")",
":",
"return",
"IMPL",
".",
"floating_ip_deallocate",
"(",
"context",
",",
"address",
")"
] |
deallocate a floating ip by address .
|
train
| false
|
13,975
|
def _is_nthpow_residue_bign_prime_power(a, n, p, k):
if (a % p):
if (p != 2):
return _is_nthpow_residue_bign(a, n, pow(p, k))
if (n & 1):
return True
c = trailing(n)
return ((a % pow(2, min((c + 2), k))) == 1)
else:
a %= pow(p, k)
if (not a):
return True
mu = multiplicity(p, a)
if (mu % n):
return False
pm = pow(p, mu)
return _is_nthpow_residue_bign_prime_power((a // pm), n, p, (k - mu))
|
[
"def",
"_is_nthpow_residue_bign_prime_power",
"(",
"a",
",",
"n",
",",
"p",
",",
"k",
")",
":",
"if",
"(",
"a",
"%",
"p",
")",
":",
"if",
"(",
"p",
"!=",
"2",
")",
":",
"return",
"_is_nthpow_residue_bign",
"(",
"a",
",",
"n",
",",
"pow",
"(",
"p",
",",
"k",
")",
")",
"if",
"(",
"n",
"&",
"1",
")",
":",
"return",
"True",
"c",
"=",
"trailing",
"(",
"n",
")",
"return",
"(",
"(",
"a",
"%",
"pow",
"(",
"2",
",",
"min",
"(",
"(",
"c",
"+",
"2",
")",
",",
"k",
")",
")",
")",
"==",
"1",
")",
"else",
":",
"a",
"%=",
"pow",
"(",
"p",
",",
"k",
")",
"if",
"(",
"not",
"a",
")",
":",
"return",
"True",
"mu",
"=",
"multiplicity",
"(",
"p",
",",
"a",
")",
"if",
"(",
"mu",
"%",
"n",
")",
":",
"return",
"False",
"pm",
"=",
"pow",
"(",
"p",
",",
"mu",
")",
"return",
"_is_nthpow_residue_bign_prime_power",
"(",
"(",
"a",
"//",
"pm",
")",
",",
"n",
",",
"p",
",",
"(",
"k",
"-",
"mu",
")",
")"
] |
returns true/false if a solution for x**n == a (mod) does/doesnt exist .
|
train
| false
|
13,976
|
@nottest
def get_ignored_tests():
return _get_tests('ignored.xml', NOSE_IGNORE_SELECTOR, NOSE_COLLECT_IGNORE_PARAMS)
|
[
"@",
"nottest",
"def",
"get_ignored_tests",
"(",
")",
":",
"return",
"_get_tests",
"(",
"'ignored.xml'",
",",
"NOSE_IGNORE_SELECTOR",
",",
"NOSE_COLLECT_IGNORE_PARAMS",
")"
] |
collect all ignored tests and return them :return: a test suite as returned by xunitparser with all the tests available in the w3af framework source code .
|
train
| false
|
13,977
|
def _make_set(var):
if (var is None):
return set()
if (not isinstance(var, list)):
if isinstance(var, str):
var = var.split()
else:
var = list(var)
return set(var)
|
[
"def",
"_make_set",
"(",
"var",
")",
":",
"if",
"(",
"var",
"is",
"None",
")",
":",
"return",
"set",
"(",
")",
"if",
"(",
"not",
"isinstance",
"(",
"var",
",",
"list",
")",
")",
":",
"if",
"isinstance",
"(",
"var",
",",
"str",
")",
":",
"var",
"=",
"var",
".",
"split",
"(",
")",
"else",
":",
"var",
"=",
"list",
"(",
"var",
")",
"return",
"set",
"(",
"var",
")"
] |
force var to be a set .
|
train
| false
|
13,978
|
def float_range(value):
try:
value = float(value)
except:
raise argparse.ArgumentTypeError("Invalid float value: '{}'".format(value))
if ((value < 0.0) or (value > 1.0)):
raise argparse.ArgumentTypeError("Invalid float value: '{}'".format(value))
return value
|
[
"def",
"float_range",
"(",
"value",
")",
":",
"try",
":",
"value",
"=",
"float",
"(",
"value",
")",
"except",
":",
"raise",
"argparse",
".",
"ArgumentTypeError",
"(",
"\"Invalid float value: '{}'\"",
".",
"format",
"(",
"value",
")",
")",
"if",
"(",
"(",
"value",
"<",
"0.0",
")",
"or",
"(",
"value",
">",
"1.0",
")",
")",
":",
"raise",
"argparse",
".",
"ArgumentTypeError",
"(",
"\"Invalid float value: '{}'\"",
".",
"format",
"(",
"value",
")",
")",
"return",
"value"
] |
ensures that the provided value is a float integer in the range [0 .
|
train
| true
|
13,979
|
def get_casava_version(fastq1):
if isinstance(fastq1, list):
fastq_read_f_line1 = fastq1[0]
else:
fastq_read_f_line1 = fastq1.readline()
fastq1.seek(0)
post_casava_v180 = is_casava_v180_or_later(fastq_read_f_line1)
if post_casava_v180:
check_header_match_f = check_header_match_180_or_later
else:
check_header_match_f = check_header_match_pre180
return check_header_match_f
|
[
"def",
"get_casava_version",
"(",
"fastq1",
")",
":",
"if",
"isinstance",
"(",
"fastq1",
",",
"list",
")",
":",
"fastq_read_f_line1",
"=",
"fastq1",
"[",
"0",
"]",
"else",
":",
"fastq_read_f_line1",
"=",
"fastq1",
".",
"readline",
"(",
")",
"fastq1",
".",
"seek",
"(",
"0",
")",
"post_casava_v180",
"=",
"is_casava_v180_or_later",
"(",
"fastq_read_f_line1",
")",
"if",
"post_casava_v180",
":",
"check_header_match_f",
"=",
"check_header_match_180_or_later",
"else",
":",
"check_header_match_f",
"=",
"check_header_match_pre180",
"return",
"check_header_match_f"
] |
determine the version of casava that was used to generate the fastq fastq1: open fastq file or list of lines .
|
train
| false
|
13,981
|
def key_entry_name_order(entry):
return entry[0]
|
[
"def",
"key_entry_name_order",
"(",
"entry",
")",
":",
"return",
"entry",
"[",
"0",
"]"
] |
sort key for tree entry in name order .
|
train
| false
|
13,982
|
def move_to_element(browser, css_selector, header_height=155):
wait_until_condition(browser, (lambda x: x.is_element_present_by_css(css_selector)))
element = browser.driver.find_element_by_css_selector(css_selector)
y = (element.location['y'] - header_height)
browser.execute_script(('window.scrollTo(0, %s)' % y))
|
[
"def",
"move_to_element",
"(",
"browser",
",",
"css_selector",
",",
"header_height",
"=",
"155",
")",
":",
"wait_until_condition",
"(",
"browser",
",",
"(",
"lambda",
"x",
":",
"x",
".",
"is_element_present_by_css",
"(",
"css_selector",
")",
")",
")",
"element",
"=",
"browser",
".",
"driver",
".",
"find_element_by_css_selector",
"(",
"css_selector",
")",
"y",
"=",
"(",
"element",
".",
"location",
"[",
"'y'",
"]",
"-",
"header_height",
")",
"browser",
".",
"execute_script",
"(",
"(",
"'window.scrollTo(0, %s)'",
"%",
"y",
")",
")"
] |
scroll the browser window to the element .
|
train
| false
|
13,983
|
def list_saml_providers(region=None, key=None, keyid=None, profile=None):
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
try:
providers = []
info = conn.list_saml_providers()
for arn in info['list_saml_providers_response']['list_saml_providers_result']['saml_provider_list']:
providers.append(arn['arn'].rsplit('/', 1)[1])
return providers
except boto.exception.BotoServerError as e:
aws = __utils__['boto.get_error'](e)
log.debug(aws)
msg = 'Failed to get list of SAML providers.'
log.error(msg)
return False
|
[
"def",
"list_saml_providers",
"(",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
"=",
"region",
",",
"key",
"=",
"key",
",",
"keyid",
"=",
"keyid",
",",
"profile",
"=",
"profile",
")",
"try",
":",
"providers",
"=",
"[",
"]",
"info",
"=",
"conn",
".",
"list_saml_providers",
"(",
")",
"for",
"arn",
"in",
"info",
"[",
"'list_saml_providers_response'",
"]",
"[",
"'list_saml_providers_result'",
"]",
"[",
"'saml_provider_list'",
"]",
":",
"providers",
".",
"append",
"(",
"arn",
"[",
"'arn'",
"]",
".",
"rsplit",
"(",
"'/'",
",",
"1",
")",
"[",
"1",
"]",
")",
"return",
"providers",
"except",
"boto",
".",
"exception",
".",
"BotoServerError",
"as",
"e",
":",
"aws",
"=",
"__utils__",
"[",
"'boto.get_error'",
"]",
"(",
"e",
")",
"log",
".",
"debug",
"(",
"aws",
")",
"msg",
"=",
"'Failed to get list of SAML providers.'",
"log",
".",
"error",
"(",
"msg",
")",
"return",
"False"
] |
list saml providers .
|
train
| true
|
13,984
|
def _get_host_disks(host_reference):
storage_system = host_reference.configManager.storageSystem
disks = storage_system.storageDeviceInfo.scsiLun
ssds = []
non_ssds = []
for disk in disks:
try:
has_ssd_attr = disk.ssd
except AttributeError:
has_ssd_attr = False
if has_ssd_attr:
ssds.append(disk)
else:
non_ssds.append(disk)
return {'SSDs': ssds, 'Non-SSDs': non_ssds}
|
[
"def",
"_get_host_disks",
"(",
"host_reference",
")",
":",
"storage_system",
"=",
"host_reference",
".",
"configManager",
".",
"storageSystem",
"disks",
"=",
"storage_system",
".",
"storageDeviceInfo",
".",
"scsiLun",
"ssds",
"=",
"[",
"]",
"non_ssds",
"=",
"[",
"]",
"for",
"disk",
"in",
"disks",
":",
"try",
":",
"has_ssd_attr",
"=",
"disk",
".",
"ssd",
"except",
"AttributeError",
":",
"has_ssd_attr",
"=",
"False",
"if",
"has_ssd_attr",
":",
"ssds",
".",
"append",
"(",
"disk",
")",
"else",
":",
"non_ssds",
".",
"append",
"(",
"disk",
")",
"return",
"{",
"'SSDs'",
":",
"ssds",
",",
"'Non-SSDs'",
":",
"non_ssds",
"}"
] |
helper function that returns a dictionary containing a list of ssd and non-ssd disks .
|
train
| true
|
13,986
|
def _normalize_string(orig):
return orig.replace('"', '').replace("'", '').strip()
|
[
"def",
"_normalize_string",
"(",
"orig",
")",
":",
"return",
"orig",
".",
"replace",
"(",
"'\"'",
",",
"''",
")",
".",
"replace",
"(",
"\"'\"",
",",
"''",
")",
".",
"strip",
"(",
")"
] |
helper function for _get_systemd_os_release_var() to remove quotes and whitespaces .
|
train
| false
|
13,987
|
def host_subplot(*args, **kwargs):
import matplotlib.pyplot as plt
axes_class = kwargs.pop(u'axes_class', None)
host_subplot_class = host_subplot_class_factory(axes_class)
fig = kwargs.get(u'figure', None)
if (fig is None):
fig = plt.gcf()
ax = host_subplot_class(fig, *args, **kwargs)
fig.add_subplot(ax)
plt.draw_if_interactive()
return ax
|
[
"def",
"host_subplot",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"import",
"matplotlib",
".",
"pyplot",
"as",
"plt",
"axes_class",
"=",
"kwargs",
".",
"pop",
"(",
"u'axes_class'",
",",
"None",
")",
"host_subplot_class",
"=",
"host_subplot_class_factory",
"(",
"axes_class",
")",
"fig",
"=",
"kwargs",
".",
"get",
"(",
"u'figure'",
",",
"None",
")",
"if",
"(",
"fig",
"is",
"None",
")",
":",
"fig",
"=",
"plt",
".",
"gcf",
"(",
")",
"ax",
"=",
"host_subplot_class",
"(",
"fig",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"fig",
".",
"add_subplot",
"(",
"ax",
")",
"plt",
".",
"draw_if_interactive",
"(",
")",
"return",
"ax"
] |
create a subplot that can act as a host to parasitic axes .
|
train
| false
|
13,988
|
def post_view(request):
if (request.method == 'POST'):
if request.POST:
t = Template('Data received: {{ data }} is the value.', name='POST Template')
c = Context({'data': request.POST['value']})
else:
t = Template('Viewing POST page.', name='Empty POST Template')
c = Context()
else:
t = Template('Viewing GET page.', name='Empty GET Template')
c = Context()
return HttpResponse(t.render(c))
|
[
"def",
"post_view",
"(",
"request",
")",
":",
"if",
"(",
"request",
".",
"method",
"==",
"'POST'",
")",
":",
"if",
"request",
".",
"POST",
":",
"t",
"=",
"Template",
"(",
"'Data received: {{ data }} is the value.'",
",",
"name",
"=",
"'POST Template'",
")",
"c",
"=",
"Context",
"(",
"{",
"'data'",
":",
"request",
".",
"POST",
"[",
"'value'",
"]",
"}",
")",
"else",
":",
"t",
"=",
"Template",
"(",
"'Viewing POST page.'",
",",
"name",
"=",
"'Empty POST Template'",
")",
"c",
"=",
"Context",
"(",
")",
"else",
":",
"t",
"=",
"Template",
"(",
"'Viewing GET page.'",
",",
"name",
"=",
"'Empty GET Template'",
")",
"c",
"=",
"Context",
"(",
")",
"return",
"HttpResponse",
"(",
"t",
".",
"render",
"(",
"c",
")",
")"
] |
a view that expects a post .
|
train
| false
|
13,990
|
def write_float_matrix(fid, kind, mat):
FIFFT_MATRIX = (1 << 30)
FIFFT_MATRIX_FLOAT = (FIFF.FIFFT_FLOAT | FIFFT_MATRIX)
data_size = ((4 * mat.size) + (4 * (mat.ndim + 1)))
fid.write(np.array(kind, dtype='>i4').tostring())
fid.write(np.array(FIFFT_MATRIX_FLOAT, dtype='>i4').tostring())
fid.write(np.array(data_size, dtype='>i4').tostring())
fid.write(np.array(FIFF.FIFFV_NEXT_SEQ, dtype='>i4').tostring())
fid.write(np.array(mat, dtype='>f4').tostring())
dims = np.empty((mat.ndim + 1), dtype=np.int32)
dims[:mat.ndim] = mat.shape[::(-1)]
dims[(-1)] = mat.ndim
fid.write(np.array(dims, dtype='>i4').tostring())
check_fiff_length(fid)
|
[
"def",
"write_float_matrix",
"(",
"fid",
",",
"kind",
",",
"mat",
")",
":",
"FIFFT_MATRIX",
"=",
"(",
"1",
"<<",
"30",
")",
"FIFFT_MATRIX_FLOAT",
"=",
"(",
"FIFF",
".",
"FIFFT_FLOAT",
"|",
"FIFFT_MATRIX",
")",
"data_size",
"=",
"(",
"(",
"4",
"*",
"mat",
".",
"size",
")",
"+",
"(",
"4",
"*",
"(",
"mat",
".",
"ndim",
"+",
"1",
")",
")",
")",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"kind",
",",
"dtype",
"=",
"'>i4'",
")",
".",
"tostring",
"(",
")",
")",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"FIFFT_MATRIX_FLOAT",
",",
"dtype",
"=",
"'>i4'",
")",
".",
"tostring",
"(",
")",
")",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"data_size",
",",
"dtype",
"=",
"'>i4'",
")",
".",
"tostring",
"(",
")",
")",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"FIFF",
".",
"FIFFV_NEXT_SEQ",
",",
"dtype",
"=",
"'>i4'",
")",
".",
"tostring",
"(",
")",
")",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"mat",
",",
"dtype",
"=",
"'>f4'",
")",
".",
"tostring",
"(",
")",
")",
"dims",
"=",
"np",
".",
"empty",
"(",
"(",
"mat",
".",
"ndim",
"+",
"1",
")",
",",
"dtype",
"=",
"np",
".",
"int32",
")",
"dims",
"[",
":",
"mat",
".",
"ndim",
"]",
"=",
"mat",
".",
"shape",
"[",
":",
":",
"(",
"-",
"1",
")",
"]",
"dims",
"[",
"(",
"-",
"1",
")",
"]",
"=",
"mat",
".",
"ndim",
"fid",
".",
"write",
"(",
"np",
".",
"array",
"(",
"dims",
",",
"dtype",
"=",
"'>i4'",
")",
".",
"tostring",
"(",
")",
")",
"check_fiff_length",
"(",
"fid",
")"
] |
write a single-precision floating-point matrix tag .
|
train
| false
|
13,992
|
def _showwarning(message, category, filename, lineno, file=None, line=None):
if (file is not None):
if (_warnings_showwarning is not None):
_warnings_showwarning(message, category, filename, lineno, file, line)
else:
s = warnings.formatwarning(message, category, filename, lineno, line)
logger = getLogger('py.warnings')
if (not logger.handlers):
logger.addHandler(NullHandler())
logger.warning('%s', s)
|
[
"def",
"_showwarning",
"(",
"message",
",",
"category",
",",
"filename",
",",
"lineno",
",",
"file",
"=",
"None",
",",
"line",
"=",
"None",
")",
":",
"if",
"(",
"file",
"is",
"not",
"None",
")",
":",
"if",
"(",
"_warnings_showwarning",
"is",
"not",
"None",
")",
":",
"_warnings_showwarning",
"(",
"message",
",",
"category",
",",
"filename",
",",
"lineno",
",",
"file",
",",
"line",
")",
"else",
":",
"s",
"=",
"warnings",
".",
"formatwarning",
"(",
"message",
",",
"category",
",",
"filename",
",",
"lineno",
",",
"line",
")",
"logger",
"=",
"getLogger",
"(",
"'py.warnings'",
")",
"if",
"(",
"not",
"logger",
".",
"handlers",
")",
":",
"logger",
".",
"addHandler",
"(",
"NullHandler",
"(",
")",
")",
"logger",
".",
"warning",
"(",
"'%s'",
",",
"s",
")"
] |
implementation of showwarnings which redirects to logging .
|
train
| false
|
13,993
|
def test_half_pie():
pie = Pie()
pie.add('IE', 19.5)
pie.add('Firefox', 36.6)
pie.add('Chrome', 36.3)
pie.add('Safari', 4.5)
pie.add('Opera', 2.3)
half = Pie(half_pie=True)
half.add('IE', 19.5)
half.add('Firefox', 36.6)
half.add('Chrome', 36.3)
half.add('Safari', 4.5)
half.add('Opera', 2.3)
assert (pie.render() != half.render())
|
[
"def",
"test_half_pie",
"(",
")",
":",
"pie",
"=",
"Pie",
"(",
")",
"pie",
".",
"add",
"(",
"'IE'",
",",
"19.5",
")",
"pie",
".",
"add",
"(",
"'Firefox'",
",",
"36.6",
")",
"pie",
".",
"add",
"(",
"'Chrome'",
",",
"36.3",
")",
"pie",
".",
"add",
"(",
"'Safari'",
",",
"4.5",
")",
"pie",
".",
"add",
"(",
"'Opera'",
",",
"2.3",
")",
"half",
"=",
"Pie",
"(",
"half_pie",
"=",
"True",
")",
"half",
".",
"add",
"(",
"'IE'",
",",
"19.5",
")",
"half",
".",
"add",
"(",
"'Firefox'",
",",
"36.6",
")",
"half",
".",
"add",
"(",
"'Chrome'",
",",
"36.3",
")",
"half",
".",
"add",
"(",
"'Safari'",
",",
"4.5",
")",
"half",
".",
"add",
"(",
"'Opera'",
",",
"2.3",
")",
"assert",
"(",
"pie",
".",
"render",
"(",
")",
"!=",
"half",
".",
"render",
"(",
")",
")"
] |
test a half pie chart .
|
train
| false
|
13,994
|
def long_int(hash_key):
if (sys.version_info < (3,)):
return long(hash_key)
else:
return int(hash_key)
|
[
"def",
"long_int",
"(",
"hash_key",
")",
":",
"if",
"(",
"sys",
".",
"version_info",
"<",
"(",
"3",
",",
")",
")",
":",
"return",
"long",
"(",
"hash_key",
")",
"else",
":",
"return",
"int",
"(",
"hash_key",
")"
] |
the hash key is a 128-bit int .
|
train
| false
|
13,995
|
@contextmanager
def hard_exit_handler():
try:
(yield)
except HardSystemExit:
os._exit(0)
|
[
"@",
"contextmanager",
"def",
"hard_exit_handler",
"(",
")",
":",
"try",
":",
"(",
"yield",
")",
"except",
"HardSystemExit",
":",
"os",
".",
"_exit",
"(",
"0",
")"
] |
an exit helper for the daemon/forkd context that provides for deferred os .
|
train
| false
|
13,996
|
@task
@needs('pavelib.prereqs.install_prereqs')
@cmdopts([('settings=', 's', 'Django settings'), ('asset-settings=', 'a', ASSET_SETTINGS_HELP), ('port=', 'p', 'Port'), ('fast', 'f', 'Skip updating assets')])
def lms(options):
settings = getattr(options, 'settings', DEFAULT_SETTINGS)
asset_settings = getattr(options, 'asset-settings', settings)
port = getattr(options, 'port', None)
fast = getattr(options, 'fast', False)
run_server('lms', fast=fast, settings=settings, asset_settings=asset_settings, port=port)
|
[
"@",
"task",
"@",
"needs",
"(",
"'pavelib.prereqs.install_prereqs'",
")",
"@",
"cmdopts",
"(",
"[",
"(",
"'settings='",
",",
"'s'",
",",
"'Django settings'",
")",
",",
"(",
"'asset-settings='",
",",
"'a'",
",",
"ASSET_SETTINGS_HELP",
")",
",",
"(",
"'port='",
",",
"'p'",
",",
"'Port'",
")",
",",
"(",
"'fast'",
",",
"'f'",
",",
"'Skip updating assets'",
")",
"]",
")",
"def",
"lms",
"(",
"options",
")",
":",
"settings",
"=",
"getattr",
"(",
"options",
",",
"'settings'",
",",
"DEFAULT_SETTINGS",
")",
"asset_settings",
"=",
"getattr",
"(",
"options",
",",
"'asset-settings'",
",",
"settings",
")",
"port",
"=",
"getattr",
"(",
"options",
",",
"'port'",
",",
"None",
")",
"fast",
"=",
"getattr",
"(",
"options",
",",
"'fast'",
",",
"False",
")",
"run_server",
"(",
"'lms'",
",",
"fast",
"=",
"fast",
",",
"settings",
"=",
"settings",
",",
"asset_settings",
"=",
"asset_settings",
",",
"port",
"=",
"port",
")"
] |
run the lms server .
|
train
| false
|
13,997
|
def slice2gridspec(key):
if ((len(key) != 2) or (not isinstance(key[0], slice)) or (not isinstance(key[1], slice))):
raise ValueError('only 2-D slices, please')
x0 = key[1].start
x1 = key[1].stop
xstep = key[1].step
if ((not isinstance(xstep, complex)) or (int(xstep.real) != xstep.real)):
raise ValueError('only the [start:stop:numsteps*1j] form supported')
xstep = int(xstep.imag)
y0 = key[0].start
y1 = key[0].stop
ystep = key[0].step
if ((not isinstance(ystep, complex)) or (int(ystep.real) != ystep.real)):
raise ValueError('only the [start:stop:numsteps*1j] form supported')
ystep = int(ystep.imag)
return (x0, x1, xstep, y0, y1, ystep)
|
[
"def",
"slice2gridspec",
"(",
"key",
")",
":",
"if",
"(",
"(",
"len",
"(",
"key",
")",
"!=",
"2",
")",
"or",
"(",
"not",
"isinstance",
"(",
"key",
"[",
"0",
"]",
",",
"slice",
")",
")",
"or",
"(",
"not",
"isinstance",
"(",
"key",
"[",
"1",
"]",
",",
"slice",
")",
")",
")",
":",
"raise",
"ValueError",
"(",
"'only 2-D slices, please'",
")",
"x0",
"=",
"key",
"[",
"1",
"]",
".",
"start",
"x1",
"=",
"key",
"[",
"1",
"]",
".",
"stop",
"xstep",
"=",
"key",
"[",
"1",
"]",
".",
"step",
"if",
"(",
"(",
"not",
"isinstance",
"(",
"xstep",
",",
"complex",
")",
")",
"or",
"(",
"int",
"(",
"xstep",
".",
"real",
")",
"!=",
"xstep",
".",
"real",
")",
")",
":",
"raise",
"ValueError",
"(",
"'only the [start:stop:numsteps*1j] form supported'",
")",
"xstep",
"=",
"int",
"(",
"xstep",
".",
"imag",
")",
"y0",
"=",
"key",
"[",
"0",
"]",
".",
"start",
"y1",
"=",
"key",
"[",
"0",
"]",
".",
"stop",
"ystep",
"=",
"key",
"[",
"0",
"]",
".",
"step",
"if",
"(",
"(",
"not",
"isinstance",
"(",
"ystep",
",",
"complex",
")",
")",
"or",
"(",
"int",
"(",
"ystep",
".",
"real",
")",
"!=",
"ystep",
".",
"real",
")",
")",
":",
"raise",
"ValueError",
"(",
"'only the [start:stop:numsteps*1j] form supported'",
")",
"ystep",
"=",
"int",
"(",
"ystep",
".",
"imag",
")",
"return",
"(",
"x0",
",",
"x1",
",",
"xstep",
",",
"y0",
",",
"y1",
",",
"ystep",
")"
] |
convert a 2-tuple of slices to start .
|
train
| false
|
13,998
|
def _clean_win_chars(string):
import urllib
if hasattr(urllib, 'quote'):
quote = urllib.quote
else:
import urllib.parse
quote = urllib.parse.quote
for char in ('<', '>', '!', ':', '\\'):
string = string.replace(char, quote(char))
return string
|
[
"def",
"_clean_win_chars",
"(",
"string",
")",
":",
"import",
"urllib",
"if",
"hasattr",
"(",
"urllib",
",",
"'quote'",
")",
":",
"quote",
"=",
"urllib",
".",
"quote",
"else",
":",
"import",
"urllib",
".",
"parse",
"quote",
"=",
"urllib",
".",
"parse",
".",
"quote",
"for",
"char",
"in",
"(",
"'<'",
",",
"'>'",
",",
"'!'",
",",
"':'",
",",
"'\\\\'",
")",
":",
"string",
"=",
"string",
".",
"replace",
"(",
"char",
",",
"quote",
"(",
"char",
")",
")",
"return",
"string"
] |
windows cannot encode some characters in filename .
|
train
| false
|
14,001
|
def BFS(gr, s):
if (not gr.has_node(s)):
raise Exception(('Node %s not in graph' % s))
nodes_explored = set([s])
q = deque([s])
while (len(q) != 0):
node = q.popleft()
for each in gr.neighbors(node):
if (each not in nodes_explored):
nodes_explored.add(each)
q.append(each)
return nodes_explored
|
[
"def",
"BFS",
"(",
"gr",
",",
"s",
")",
":",
"if",
"(",
"not",
"gr",
".",
"has_node",
"(",
"s",
")",
")",
":",
"raise",
"Exception",
"(",
"(",
"'Node %s not in graph'",
"%",
"s",
")",
")",
"nodes_explored",
"=",
"set",
"(",
"[",
"s",
"]",
")",
"q",
"=",
"deque",
"(",
"[",
"s",
"]",
")",
"while",
"(",
"len",
"(",
"q",
")",
"!=",
"0",
")",
":",
"node",
"=",
"q",
".",
"popleft",
"(",
")",
"for",
"each",
"in",
"gr",
".",
"neighbors",
"(",
"node",
")",
":",
"if",
"(",
"each",
"not",
"in",
"nodes_explored",
")",
":",
"nodes_explored",
".",
"add",
"(",
"each",
")",
"q",
".",
"append",
"(",
"each",
")",
"return",
"nodes_explored"
] |
breadth first search returns a list of nodes that are "findable" from s .
|
train
| false
|
14,003
|
def set_event_transaction_id(new_id):
get_cache('event_transaction')['id'] = UUID(new_id)
|
[
"def",
"set_event_transaction_id",
"(",
"new_id",
")",
":",
"get_cache",
"(",
"'event_transaction'",
")",
"[",
"'id'",
"]",
"=",
"UUID",
"(",
"new_id",
")"
] |
sets the event transaction id to a uuid object generated from new_id .
|
train
| false
|
14,004
|
def getNewDerivation(elementNode):
return evaluate.EmptyObject(elementNode)
|
[
"def",
"getNewDerivation",
"(",
"elementNode",
")",
":",
"return",
"evaluate",
".",
"EmptyObject",
"(",
"elementNode",
")"
] |
get new derivation .
|
train
| false
|
14,005
|
def activity_age_group():
return s3_rest_controller()
|
[
"def",
"activity_age_group",
"(",
")",
":",
"return",
"s3_rest_controller",
"(",
")"
] |
activity age groups: restful crud controller .
|
train
| false
|
14,006
|
def test_ast_bad_yield():
cant_compile(u'(yield 1 2)')
|
[
"def",
"test_ast_bad_yield",
"(",
")",
":",
"cant_compile",
"(",
"u'(yield 1 2)'",
")"
] |
make sure ast cant compile invalid yield .
|
train
| false
|
14,007
|
def _api_queue_default(output, value, kwargs):
sort = kwargs.get('sort')
direction = kwargs.get('dir', '')
start = int_conv(kwargs.get('start'))
limit = int_conv(kwargs.get('limit'))
trans = kwargs.get('trans')
search = kwargs.get('search')
if (output in ('xml', 'json')):
if (sort and (sort != 'index')):
reverse = (direction.lower() == 'desc')
sort_queue(sort, reverse)
(info, pnfo_list, bytespersec) = build_queue(start=start, limit=limit, output=output, trans=trans, search=search)
info['categories'] = info.pop('cat_list')
info['scripts'] = info.pop('script_list')
return report(output, keyword='queue', data=remove_callable(info))
elif (output == 'rss'):
return rss_qstatus()
else:
return report(output, _MSG_NOT_IMPLEMENTED)
|
[
"def",
"_api_queue_default",
"(",
"output",
",",
"value",
",",
"kwargs",
")",
":",
"sort",
"=",
"kwargs",
".",
"get",
"(",
"'sort'",
")",
"direction",
"=",
"kwargs",
".",
"get",
"(",
"'dir'",
",",
"''",
")",
"start",
"=",
"int_conv",
"(",
"kwargs",
".",
"get",
"(",
"'start'",
")",
")",
"limit",
"=",
"int_conv",
"(",
"kwargs",
".",
"get",
"(",
"'limit'",
")",
")",
"trans",
"=",
"kwargs",
".",
"get",
"(",
"'trans'",
")",
"search",
"=",
"kwargs",
".",
"get",
"(",
"'search'",
")",
"if",
"(",
"output",
"in",
"(",
"'xml'",
",",
"'json'",
")",
")",
":",
"if",
"(",
"sort",
"and",
"(",
"sort",
"!=",
"'index'",
")",
")",
":",
"reverse",
"=",
"(",
"direction",
".",
"lower",
"(",
")",
"==",
"'desc'",
")",
"sort_queue",
"(",
"sort",
",",
"reverse",
")",
"(",
"info",
",",
"pnfo_list",
",",
"bytespersec",
")",
"=",
"build_queue",
"(",
"start",
"=",
"start",
",",
"limit",
"=",
"limit",
",",
"output",
"=",
"output",
",",
"trans",
"=",
"trans",
",",
"search",
"=",
"search",
")",
"info",
"[",
"'categories'",
"]",
"=",
"info",
".",
"pop",
"(",
"'cat_list'",
")",
"info",
"[",
"'scripts'",
"]",
"=",
"info",
".",
"pop",
"(",
"'script_list'",
")",
"return",
"report",
"(",
"output",
",",
"keyword",
"=",
"'queue'",
",",
"data",
"=",
"remove_callable",
"(",
"info",
")",
")",
"elif",
"(",
"output",
"==",
"'rss'",
")",
":",
"return",
"rss_qstatus",
"(",
")",
"else",
":",
"return",
"report",
"(",
"output",
",",
"_MSG_NOT_IMPLEMENTED",
")"
] |
api: accepts output .
|
train
| false
|
14,009
|
def _aslist(obj):
if (obj is None):
return []
elif isinstance(obj, (list, tuple)):
return obj
else:
return [obj]
|
[
"def",
"_aslist",
"(",
"obj",
")",
":",
"if",
"(",
"obj",
"is",
"None",
")",
":",
"return",
"[",
"]",
"elif",
"isinstance",
"(",
"obj",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"return",
"obj",
"else",
":",
"return",
"[",
"obj",
"]"
] |
turn object into a list; lists and tuples are left as-is .
|
train
| false
|
14,010
|
def disable_print():
sys.stdout = None
sys.stderr = os.devnull
|
[
"def",
"disable_print",
"(",
")",
":",
"sys",
".",
"stdout",
"=",
"None",
"sys",
".",
"stderr",
"=",
"os",
".",
"devnull"
] |
disable console output .
|
train
| false
|
14,011
|
def modal(image, selem, out=None, mask=None, shift_x=False, shift_y=False):
return _apply_scalar_per_pixel(generic_cy._modal, image, selem, out=out, mask=mask, shift_x=shift_x, shift_y=shift_y)
|
[
"def",
"modal",
"(",
"image",
",",
"selem",
",",
"out",
"=",
"None",
",",
"mask",
"=",
"None",
",",
"shift_x",
"=",
"False",
",",
"shift_y",
"=",
"False",
")",
":",
"return",
"_apply_scalar_per_pixel",
"(",
"generic_cy",
".",
"_modal",
",",
"image",
",",
"selem",
",",
"out",
"=",
"out",
",",
"mask",
"=",
"mask",
",",
"shift_x",
"=",
"shift_x",
",",
"shift_y",
"=",
"shift_y",
")"
] |
return local mode of an image .
|
train
| false
|
14,012
|
def condense_whitespace(css):
return re.sub('\\s+', ' ', css)
|
[
"def",
"condense_whitespace",
"(",
"css",
")",
":",
"return",
"re",
".",
"sub",
"(",
"'\\\\s+'",
",",
"' '",
",",
"css",
")"
] |
condense multiple adjacent whitespace characters into one .
|
train
| false
|
14,013
|
def _set_persistent_module(mod):
if ((not mod) or (mod in mod_list(True)) or (mod not in available())):
return set()
__salt__['file.append'](_LOADER_CONF, _LOAD_MODULE.format(mod))
return set([mod])
|
[
"def",
"_set_persistent_module",
"(",
"mod",
")",
":",
"if",
"(",
"(",
"not",
"mod",
")",
"or",
"(",
"mod",
"in",
"mod_list",
"(",
"True",
")",
")",
"or",
"(",
"mod",
"not",
"in",
"available",
"(",
")",
")",
")",
":",
"return",
"set",
"(",
")",
"__salt__",
"[",
"'file.append'",
"]",
"(",
"_LOADER_CONF",
",",
"_LOAD_MODULE",
".",
"format",
"(",
"mod",
")",
")",
"return",
"set",
"(",
"[",
"mod",
"]",
")"
] |
add module to configuration file to make it persistent .
|
train
| true
|
14,014
|
def get_permission_labels():
for plugin in plugins.PluginImplementations(plugins.IPermissionLabels):
return plugin
return DefaultPermissionLabels()
|
[
"def",
"get_permission_labels",
"(",
")",
":",
"for",
"plugin",
"in",
"plugins",
".",
"PluginImplementations",
"(",
"plugins",
".",
"IPermissionLabels",
")",
":",
"return",
"plugin",
"return",
"DefaultPermissionLabels",
"(",
")"
] |
return the permission label plugin .
|
train
| false
|
14,015
|
def _parseClientTCP(**kwargs):
kwargs['port'] = int(kwargs['port'])
try:
kwargs['timeout'] = int(kwargs['timeout'])
except KeyError:
pass
return kwargs
|
[
"def",
"_parseClientTCP",
"(",
"**",
"kwargs",
")",
":",
"kwargs",
"[",
"'port'",
"]",
"=",
"int",
"(",
"kwargs",
"[",
"'port'",
"]",
")",
"try",
":",
"kwargs",
"[",
"'timeout'",
"]",
"=",
"int",
"(",
"kwargs",
"[",
"'timeout'",
"]",
")",
"except",
"KeyError",
":",
"pass",
"return",
"kwargs"
] |
perform any argument value coercion necessary for tcp client parameters .
|
train
| false
|
14,016
|
def test_kmeans():
X = np.random.random(size=(100, 10))
Y = np.random.randint(5, size=(100, 1))
dataset = DenseDesignMatrix(X, y=Y)
model = KMeans(k=5, nvis=10)
train = Train(model=model, dataset=dataset)
train.main_loop()
|
[
"def",
"test_kmeans",
"(",
")",
":",
"X",
"=",
"np",
".",
"random",
".",
"random",
"(",
"size",
"=",
"(",
"100",
",",
"10",
")",
")",
"Y",
"=",
"np",
".",
"random",
".",
"randint",
"(",
"5",
",",
"size",
"=",
"(",
"100",
",",
"1",
")",
")",
"dataset",
"=",
"DenseDesignMatrix",
"(",
"X",
",",
"y",
"=",
"Y",
")",
"model",
"=",
"KMeans",
"(",
"k",
"=",
"5",
",",
"nvis",
"=",
"10",
")",
"train",
"=",
"Train",
"(",
"model",
"=",
"model",
",",
"dataset",
"=",
"dataset",
")",
"train",
".",
"main_loop",
"(",
")"
] |
tests kmeans .
|
train
| false
|
14,017
|
def remove_volumes(paths):
errors = []
for path in paths:
clear_volume(path)
lvremove = ('lvremove', '-f', path)
try:
utils.execute(attempts=3, run_as_root=True, *lvremove)
except processutils.ProcessExecutionError as exp:
errors.append(six.text_type(exp))
if errors:
raise exception.VolumesNotRemoved(reason=', '.join(errors))
|
[
"def",
"remove_volumes",
"(",
"paths",
")",
":",
"errors",
"=",
"[",
"]",
"for",
"path",
"in",
"paths",
":",
"clear_volume",
"(",
"path",
")",
"lvremove",
"=",
"(",
"'lvremove'",
",",
"'-f'",
",",
"path",
")",
"try",
":",
"utils",
".",
"execute",
"(",
"attempts",
"=",
"3",
",",
"run_as_root",
"=",
"True",
",",
"*",
"lvremove",
")",
"except",
"processutils",
".",
"ProcessExecutionError",
"as",
"exp",
":",
"errors",
".",
"append",
"(",
"six",
".",
"text_type",
"(",
"exp",
")",
")",
"if",
"errors",
":",
"raise",
"exception",
".",
"VolumesNotRemoved",
"(",
"reason",
"=",
"', '",
".",
"join",
"(",
"errors",
")",
")"
] |
remove one or more logical volume .
|
train
| false
|
14,019
|
def sanitize_prefix(function):
@functools.wraps(function)
def wrapper(*args, **kwargs):
args = list(args)
offset = 1
if ('prefix' in kwargs):
kwargs['prefix'] = name_or_value(kwargs['prefix'])
elif ((len(args) - 1) >= offset):
args[offset] = name_or_value(args[offset])
offset += 1
if ('key' in kwargs):
kwargs['key'] = name_or_value(kwargs['key'])
elif ((len(args) - 1) >= offset):
args[offset] = name_or_value(args[offset])
return function(*tuple(args), **kwargs)
return wrapper
|
[
"def",
"sanitize_prefix",
"(",
"function",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"function",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"args",
"=",
"list",
"(",
"args",
")",
"offset",
"=",
"1",
"if",
"(",
"'prefix'",
"in",
"kwargs",
")",
":",
"kwargs",
"[",
"'prefix'",
"]",
"=",
"name_or_value",
"(",
"kwargs",
"[",
"'prefix'",
"]",
")",
"elif",
"(",
"(",
"len",
"(",
"args",
")",
"-",
"1",
")",
">=",
"offset",
")",
":",
"args",
"[",
"offset",
"]",
"=",
"name_or_value",
"(",
"args",
"[",
"offset",
"]",
")",
"offset",
"+=",
"1",
"if",
"(",
"'key'",
"in",
"kwargs",
")",
":",
"kwargs",
"[",
"'key'",
"]",
"=",
"name_or_value",
"(",
"kwargs",
"[",
"'key'",
"]",
")",
"elif",
"(",
"(",
"len",
"(",
"args",
")",
"-",
"1",
")",
">=",
"offset",
")",
":",
"args",
"[",
"offset",
"]",
"=",
"name_or_value",
"(",
"args",
"[",
"offset",
"]",
")",
"return",
"function",
"(",
"*",
"tuple",
"(",
"args",
")",
",",
"**",
"kwargs",
")",
"return",
"wrapper"
] |
automatically call name_or_value on the prefix passed in .
|
train
| false
|
14,020
|
def version2float(s):
s = s.split('-')[0]
s = '.'.join(s.split('.')[:2])
s = ''.join((c for c in s if (c.isdigit() or (c == '.'))))
return float(s)
|
[
"def",
"version2float",
"(",
"s",
")",
":",
"s",
"=",
"s",
".",
"split",
"(",
"'-'",
")",
"[",
"0",
"]",
"s",
"=",
"'.'",
".",
"join",
"(",
"s",
".",
"split",
"(",
"'.'",
")",
"[",
":",
"2",
"]",
")",
"s",
"=",
"''",
".",
"join",
"(",
"(",
"c",
"for",
"c",
"in",
"s",
"if",
"(",
"c",
".",
"isdigit",
"(",
")",
"or",
"(",
"c",
"==",
"'.'",
")",
")",
")",
")",
"return",
"float",
"(",
"s",
")"
] |
converts a version string to a float suitable for sorting .
|
train
| false
|
14,021
|
def test_fnpickling_protocol(tmpdir):
import pickle
obj1 = 'astring'
obj2 = ToBePickled(obj1)
for p in range((pickle.HIGHEST_PROTOCOL + 1)):
fn = str(tmpdir.join('testp{}.pickle'.format(p)))
fnpickle(obj2, fn, protocol=p)
res = fnunpickle(fn)
assert (res == obj2)
|
[
"def",
"test_fnpickling_protocol",
"(",
"tmpdir",
")",
":",
"import",
"pickle",
"obj1",
"=",
"'astring'",
"obj2",
"=",
"ToBePickled",
"(",
"obj1",
")",
"for",
"p",
"in",
"range",
"(",
"(",
"pickle",
".",
"HIGHEST_PROTOCOL",
"+",
"1",
")",
")",
":",
"fn",
"=",
"str",
"(",
"tmpdir",
".",
"join",
"(",
"'testp{}.pickle'",
".",
"format",
"(",
"p",
")",
")",
")",
"fnpickle",
"(",
"obj2",
",",
"fn",
",",
"protocol",
"=",
"p",
")",
"res",
"=",
"fnunpickle",
"(",
"fn",
")",
"assert",
"(",
"res",
"==",
"obj2",
")"
] |
tests the fnpickle and fnupickle functions ability to pickle and unpickle pickle files from all protcols .
|
train
| false
|
14,022
|
def finish_fsdev(force_cleanup=False):
if ((FSDEV_PREP_CNT == 1) or force_cleanup):
restore_disks(job=FSDEV_JOB, restore=FSDEV_RESTORE, disk_list=FSDEV_DISKLIST)
|
[
"def",
"finish_fsdev",
"(",
"force_cleanup",
"=",
"False",
")",
":",
"if",
"(",
"(",
"FSDEV_PREP_CNT",
"==",
"1",
")",
"or",
"force_cleanup",
")",
":",
"restore_disks",
"(",
"job",
"=",
"FSDEV_JOB",
",",
"restore",
"=",
"FSDEV_RESTORE",
",",
"disk_list",
"=",
"FSDEV_DISKLIST",
")"
] |
this method can be called from the test file to optionally restore all the drives used by the test to a standard ext2 format .
|
train
| false
|
14,023
|
def isInsideOtherLoops(loopIndex, loops):
return isPathInsideLoops((loops[:loopIndex] + loops[(loopIndex + 1):]), loops[loopIndex])
|
[
"def",
"isInsideOtherLoops",
"(",
"loopIndex",
",",
"loops",
")",
":",
"return",
"isPathInsideLoops",
"(",
"(",
"loops",
"[",
":",
"loopIndex",
"]",
"+",
"loops",
"[",
"(",
"loopIndex",
"+",
"1",
")",
":",
"]",
")",
",",
"loops",
"[",
"loopIndex",
"]",
")"
] |
determine if a loop in a list is inside another loop in that list .
|
train
| false
|
14,025
|
@contextlib.contextmanager
def on_error_print_details(actual, expected):
try:
(yield)
except Exception:
diff = difflib.ndiff(expected.splitlines(), actual.splitlines())
diff_text = u'\n'.join(diff)
print(u'DIFF (+ ACTUAL, - EXPECTED):\n{0}\n'.format(diff_text))
if DEBUG:
print(u'expected:\n{0}\n'.format(expected))
print(u'actual:\n{0}'.format(actual))
raise
|
[
"@",
"contextlib",
".",
"contextmanager",
"def",
"on_error_print_details",
"(",
"actual",
",",
"expected",
")",
":",
"try",
":",
"(",
"yield",
")",
"except",
"Exception",
":",
"diff",
"=",
"difflib",
".",
"ndiff",
"(",
"expected",
".",
"splitlines",
"(",
")",
",",
"actual",
".",
"splitlines",
"(",
")",
")",
"diff_text",
"=",
"u'\\n'",
".",
"join",
"(",
"diff",
")",
"print",
"(",
"u'DIFF (+ ACTUAL, - EXPECTED):\\n{0}\\n'",
".",
"format",
"(",
"diff_text",
")",
")",
"if",
"DEBUG",
":",
"print",
"(",
"u'expected:\\n{0}\\n'",
".",
"format",
"(",
"expected",
")",
")",
"print",
"(",
"u'actual:\\n{0}'",
".",
"format",
"(",
"actual",
")",
")",
"raise"
] |
print text details in case of assertation failed errors .
|
train
| false
|
14,026
|
def granular_now(n=None, default_tz=None):
if (n is None):
n = timezone.now()
if (default_tz is None):
default_tz = n.tzinfo
rounded_minute = ((n.minute // 5) * 5)
d = datetime(n.year, n.month, n.day, n.hour, rounded_minute)
try:
retval = timezone.make_aware(d, default_tz)
except AmbiguousTimeError:
try:
retval = timezone.make_aware(d, default_tz, is_dst=False)
except TypeError:
retval = timezone.make_aware(datetime(n.year, n.month, n.day, (n.hour + 1), rounded_minute), default_tz)
return retval
|
[
"def",
"granular_now",
"(",
"n",
"=",
"None",
",",
"default_tz",
"=",
"None",
")",
":",
"if",
"(",
"n",
"is",
"None",
")",
":",
"n",
"=",
"timezone",
".",
"now",
"(",
")",
"if",
"(",
"default_tz",
"is",
"None",
")",
":",
"default_tz",
"=",
"n",
".",
"tzinfo",
"rounded_minute",
"=",
"(",
"(",
"n",
".",
"minute",
"//",
"5",
")",
"*",
"5",
")",
"d",
"=",
"datetime",
"(",
"n",
".",
"year",
",",
"n",
".",
"month",
",",
"n",
".",
"day",
",",
"n",
".",
"hour",
",",
"rounded_minute",
")",
"try",
":",
"retval",
"=",
"timezone",
".",
"make_aware",
"(",
"d",
",",
"default_tz",
")",
"except",
"AmbiguousTimeError",
":",
"try",
":",
"retval",
"=",
"timezone",
".",
"make_aware",
"(",
"d",
",",
"default_tz",
",",
"is_dst",
"=",
"False",
")",
"except",
"TypeError",
":",
"retval",
"=",
"timezone",
".",
"make_aware",
"(",
"datetime",
"(",
"n",
".",
"year",
",",
"n",
".",
"month",
",",
"n",
".",
"day",
",",
"(",
"n",
".",
"hour",
"+",
"1",
")",
",",
"rounded_minute",
")",
",",
"default_tz",
")",
"return",
"retval"
] |
a datetime .
|
train
| false
|
14,027
|
def test_page():
data.page()
|
[
"def",
"test_page",
"(",
")",
":",
"data",
".",
"page",
"(",
")"
] |
test that "page" image can be loaded .
|
train
| false
|
14,028
|
def cidr_netmask(cidr):
ips = netaddr.IPNetwork(cidr)
return str(ips.netmask)
|
[
"def",
"cidr_netmask",
"(",
"cidr",
")",
":",
"ips",
"=",
"netaddr",
".",
"IPNetwork",
"(",
"cidr",
")",
"return",
"str",
"(",
"ips",
".",
"netmask",
")"
] |
get the netmask address associated with a cidr address .
|
train
| false
|
14,032
|
def yesterday():
date = datetime.datetime.now()
date -= datetime.timedelta(days=1)
date_tuple = date.timetuple()[:6]
return date_tuple
|
[
"def",
"yesterday",
"(",
")",
":",
"date",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"date",
"-=",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"1",
")",
"date_tuple",
"=",
"date",
".",
"timetuple",
"(",
")",
"[",
":",
"6",
"]",
"return",
"date_tuple"
] |
get yesterdays datetime as a 5-tuple .
|
train
| false
|
14,036
|
@commands(u'getchanneltimeformat', u'getctf')
@example(u'.getctf [channel]')
def get_channel_format(bot, trigger):
channel = trigger.group(2)
if (not channel):
channel = trigger.sender
channel = channel.strip()
tformat = bot.db.get_channel_value(channel, u'time_format')
if tformat:
bot.say((u"%s's time format: %s" % (channel, tformat)))
else:
bot.say((u'%s has no preferred time format' % channel))
|
[
"@",
"commands",
"(",
"u'getchanneltimeformat'",
",",
"u'getctf'",
")",
"@",
"example",
"(",
"u'.getctf [channel]'",
")",
"def",
"get_channel_format",
"(",
"bot",
",",
"trigger",
")",
":",
"channel",
"=",
"trigger",
".",
"group",
"(",
"2",
")",
"if",
"(",
"not",
"channel",
")",
":",
"channel",
"=",
"trigger",
".",
"sender",
"channel",
"=",
"channel",
".",
"strip",
"(",
")",
"tformat",
"=",
"bot",
".",
"db",
".",
"get_channel_value",
"(",
"channel",
",",
"u'time_format'",
")",
"if",
"tformat",
":",
"bot",
".",
"say",
"(",
"(",
"u\"%s's time format: %s\"",
"%",
"(",
"channel",
",",
"tformat",
")",
")",
")",
"else",
":",
"bot",
".",
"say",
"(",
"(",
"u'%s has no preferred time format'",
"%",
"channel",
")",
")"
] |
gets the channels preferred time format .
|
train
| false
|
14,037
|
def _dipole_forwards(fwd_data, whitener, rr, n_jobs=1):
B = _compute_forwards_meeg(rr, fwd_data, n_jobs, verbose=False)
B = np.concatenate(B, axis=1)
B_orig = B.copy()
B = np.dot(B, whitener.T)
scales = np.ones(3)
return (B, B_orig, scales)
|
[
"def",
"_dipole_forwards",
"(",
"fwd_data",
",",
"whitener",
",",
"rr",
",",
"n_jobs",
"=",
"1",
")",
":",
"B",
"=",
"_compute_forwards_meeg",
"(",
"rr",
",",
"fwd_data",
",",
"n_jobs",
",",
"verbose",
"=",
"False",
")",
"B",
"=",
"np",
".",
"concatenate",
"(",
"B",
",",
"axis",
"=",
"1",
")",
"B_orig",
"=",
"B",
".",
"copy",
"(",
")",
"B",
"=",
"np",
".",
"dot",
"(",
"B",
",",
"whitener",
".",
"T",
")",
"scales",
"=",
"np",
".",
"ones",
"(",
"3",
")",
"return",
"(",
"B",
",",
"B_orig",
",",
"scales",
")"
] |
compute the forward solution and do other nice stuff .
|
train
| false
|
14,039
|
def sinm(A):
A = _asarray_square(A)
if np.iscomplexobj(A):
return ((-0.5j) * (expm((1j * A)) - expm(((-1j) * A))))
else:
return expm((1j * A)).imag
|
[
"def",
"sinm",
"(",
"A",
")",
":",
"A",
"=",
"_asarray_square",
"(",
"A",
")",
"if",
"np",
".",
"iscomplexobj",
"(",
"A",
")",
":",
"return",
"(",
"(",
"-",
"0.5j",
")",
"*",
"(",
"expm",
"(",
"(",
"1j",
"*",
"A",
")",
")",
"-",
"expm",
"(",
"(",
"(",
"-",
"1j",
")",
"*",
"A",
")",
")",
")",
")",
"else",
":",
"return",
"expm",
"(",
"(",
"1j",
"*",
"A",
")",
")",
".",
"imag"
] |
compute the matrix sine .
|
train
| false
|
14,040
|
def _parse_template(tmpl_str):
tmpl_str = tmpl_str.strip()
if tmpl_str.startswith('{'):
tpl = json.loads(tmpl_str)
else:
try:
tpl = yaml.load(tmpl_str, Loader=YamlLoader)
except yaml.YAMLError:
try:
tpl = yaml.load(tmpl_str, Loader=yaml.SafeLoader)
except yaml.YAMLError as yea:
raise ValueError(yea)
else:
if (tpl is None):
tpl = {}
if (not (('HeatTemplateFormatVersion' in tpl) or ('heat_template_version' in tpl) or ('AWSTemplateFormatVersion' in tpl))):
raise ValueError('Template format version not found.')
return tpl
|
[
"def",
"_parse_template",
"(",
"tmpl_str",
")",
":",
"tmpl_str",
"=",
"tmpl_str",
".",
"strip",
"(",
")",
"if",
"tmpl_str",
".",
"startswith",
"(",
"'{'",
")",
":",
"tpl",
"=",
"json",
".",
"loads",
"(",
"tmpl_str",
")",
"else",
":",
"try",
":",
"tpl",
"=",
"yaml",
".",
"load",
"(",
"tmpl_str",
",",
"Loader",
"=",
"YamlLoader",
")",
"except",
"yaml",
".",
"YAMLError",
":",
"try",
":",
"tpl",
"=",
"yaml",
".",
"load",
"(",
"tmpl_str",
",",
"Loader",
"=",
"yaml",
".",
"SafeLoader",
")",
"except",
"yaml",
".",
"YAMLError",
"as",
"yea",
":",
"raise",
"ValueError",
"(",
"yea",
")",
"else",
":",
"if",
"(",
"tpl",
"is",
"None",
")",
":",
"tpl",
"=",
"{",
"}",
"if",
"(",
"not",
"(",
"(",
"'HeatTemplateFormatVersion'",
"in",
"tpl",
")",
"or",
"(",
"'heat_template_version'",
"in",
"tpl",
")",
"or",
"(",
"'AWSTemplateFormatVersion'",
"in",
"tpl",
")",
")",
")",
":",
"raise",
"ValueError",
"(",
"'Template format version not found.'",
")",
"return",
"tpl"
] |
parsing template .
|
train
| false
|
14,042
|
def wheel_delta(event):
if PYQT4:
delta = event.delta()
else:
angle = event.angleDelta()
x = angle.x()
y = angle.y()
if (abs(x) > abs(y)):
delta = x
else:
delta = y
return delta
|
[
"def",
"wheel_delta",
"(",
"event",
")",
":",
"if",
"PYQT4",
":",
"delta",
"=",
"event",
".",
"delta",
"(",
")",
"else",
":",
"angle",
"=",
"event",
".",
"angleDelta",
"(",
")",
"x",
"=",
"angle",
".",
"x",
"(",
")",
"y",
"=",
"angle",
".",
"y",
"(",
")",
"if",
"(",
"abs",
"(",
"x",
")",
">",
"abs",
"(",
"y",
")",
")",
":",
"delta",
"=",
"x",
"else",
":",
"delta",
"=",
"y",
"return",
"delta"
] |
return a single wheel delta .
|
train
| false
|
14,044
|
def RemoveSubtypeAnnotation(node, value):
attr = GetNodeAnnotation(node, Annotation.SUBTYPE)
if (attr and (value in attr)):
attr.remove(value)
SetNodeAnnotation(node, Annotation.SUBTYPE, attr)
|
[
"def",
"RemoveSubtypeAnnotation",
"(",
"node",
",",
"value",
")",
":",
"attr",
"=",
"GetNodeAnnotation",
"(",
"node",
",",
"Annotation",
".",
"SUBTYPE",
")",
"if",
"(",
"attr",
"and",
"(",
"value",
"in",
"attr",
")",
")",
":",
"attr",
".",
"remove",
"(",
"value",
")",
"SetNodeAnnotation",
"(",
"node",
",",
"Annotation",
".",
"SUBTYPE",
",",
"attr",
")"
] |
removes an annotation value from the subtype annotations on the node .
|
train
| false
|
14,045
|
def parse_distmat_to_dict(table):
(col_headers, row_headers, data) = parse_matrix(table)
assert (col_headers == row_headers)
result = defaultdict(dict)
for (sample_id_x, row) in zip(col_headers, data):
for (sample_id_y, value) in zip(row_headers, row):
result[sample_id_x][sample_id_y] = value
return result
|
[
"def",
"parse_distmat_to_dict",
"(",
"table",
")",
":",
"(",
"col_headers",
",",
"row_headers",
",",
"data",
")",
"=",
"parse_matrix",
"(",
"table",
")",
"assert",
"(",
"col_headers",
"==",
"row_headers",
")",
"result",
"=",
"defaultdict",
"(",
"dict",
")",
"for",
"(",
"sample_id_x",
",",
"row",
")",
"in",
"zip",
"(",
"col_headers",
",",
"data",
")",
":",
"for",
"(",
"sample_id_y",
",",
"value",
")",
"in",
"zip",
"(",
"row_headers",
",",
"row",
")",
":",
"result",
"[",
"sample_id_x",
"]",
"[",
"sample_id_y",
"]",
"=",
"value",
"return",
"result"
] |
parse a dist matrix into an 2d dict indexed by sample ids .
|
train
| false
|
14,046
|
def collapseStrings(results):
copy = []
begun = None
listsList = [isinstance(s, list) for s in results]
pred = (lambda e: isinstance(e, tuple))
tran = {0: (lambda e: splitQuoted(''.join(e))), 1: (lambda e: [''.join([i[0] for i in e])])}
for (i, c, isList) in zip(list(range(len(results))), results, listsList):
if isList:
if (begun is not None):
copy.extend(splitOn(results[begun:i], pred, tran))
begun = None
copy.append(collapseStrings(c))
elif (begun is None):
begun = i
if (begun is not None):
copy.extend(splitOn(results[begun:], pred, tran))
return copy
|
[
"def",
"collapseStrings",
"(",
"results",
")",
":",
"copy",
"=",
"[",
"]",
"begun",
"=",
"None",
"listsList",
"=",
"[",
"isinstance",
"(",
"s",
",",
"list",
")",
"for",
"s",
"in",
"results",
"]",
"pred",
"=",
"(",
"lambda",
"e",
":",
"isinstance",
"(",
"e",
",",
"tuple",
")",
")",
"tran",
"=",
"{",
"0",
":",
"(",
"lambda",
"e",
":",
"splitQuoted",
"(",
"''",
".",
"join",
"(",
"e",
")",
")",
")",
",",
"1",
":",
"(",
"lambda",
"e",
":",
"[",
"''",
".",
"join",
"(",
"[",
"i",
"[",
"0",
"]",
"for",
"i",
"in",
"e",
"]",
")",
"]",
")",
"}",
"for",
"(",
"i",
",",
"c",
",",
"isList",
")",
"in",
"zip",
"(",
"list",
"(",
"range",
"(",
"len",
"(",
"results",
")",
")",
")",
",",
"results",
",",
"listsList",
")",
":",
"if",
"isList",
":",
"if",
"(",
"begun",
"is",
"not",
"None",
")",
":",
"copy",
".",
"extend",
"(",
"splitOn",
"(",
"results",
"[",
"begun",
":",
"i",
"]",
",",
"pred",
",",
"tran",
")",
")",
"begun",
"=",
"None",
"copy",
".",
"append",
"(",
"collapseStrings",
"(",
"c",
")",
")",
"elif",
"(",
"begun",
"is",
"None",
")",
":",
"begun",
"=",
"i",
"if",
"(",
"begun",
"is",
"not",
"None",
")",
":",
"copy",
".",
"extend",
"(",
"splitOn",
"(",
"results",
"[",
"begun",
":",
"]",
",",
"pred",
",",
"tran",
")",
")",
"return",
"copy"
] |
turns a list of length-one strings and lists into a list of longer strings and lists .
|
train
| false
|
14,047
|
def compile_(source, filename=None, mode='exec', flags=generators.compiler_flag, dont_inherit=0):
if ((_ast is not None) and isinstance(source, _ast.AST)):
return cpy_compile(source, filename, mode, flags, dont_inherit)
_genframe = sys._getframe(1)
s = Source(source)
co = s.compile(filename, mode, flags, _genframe=_genframe)
return co
|
[
"def",
"compile_",
"(",
"source",
",",
"filename",
"=",
"None",
",",
"mode",
"=",
"'exec'",
",",
"flags",
"=",
"generators",
".",
"compiler_flag",
",",
"dont_inherit",
"=",
"0",
")",
":",
"if",
"(",
"(",
"_ast",
"is",
"not",
"None",
")",
"and",
"isinstance",
"(",
"source",
",",
"_ast",
".",
"AST",
")",
")",
":",
"return",
"cpy_compile",
"(",
"source",
",",
"filename",
",",
"mode",
",",
"flags",
",",
"dont_inherit",
")",
"_genframe",
"=",
"sys",
".",
"_getframe",
"(",
"1",
")",
"s",
"=",
"Source",
"(",
"source",
")",
"co",
"=",
"s",
".",
"compile",
"(",
"filename",
",",
"mode",
",",
"flags",
",",
"_genframe",
"=",
"_genframe",
")",
"return",
"co"
] |
compile the given source to a raw code object .
|
train
| false
|
14,048
|
def read_zfile(file_handle):
file_handle.seek(0)
header_length = (len(_ZFILE_PREFIX) + _MAX_LEN)
length = file_handle.read(header_length)
length = length[len(_ZFILE_PREFIX):]
length = int(length, 16)
next_byte = file_handle.read(1)
if (next_byte != ' '):
file_handle.seek(header_length)
data = zlib.decompress(file_handle.read(), 15, length)
assert (len(data) == length), ('Incorrect data length while decompressing %s.The file could be corrupted.' % file_handle)
return data
|
[
"def",
"read_zfile",
"(",
"file_handle",
")",
":",
"file_handle",
".",
"seek",
"(",
"0",
")",
"header_length",
"=",
"(",
"len",
"(",
"_ZFILE_PREFIX",
")",
"+",
"_MAX_LEN",
")",
"length",
"=",
"file_handle",
".",
"read",
"(",
"header_length",
")",
"length",
"=",
"length",
"[",
"len",
"(",
"_ZFILE_PREFIX",
")",
":",
"]",
"length",
"=",
"int",
"(",
"length",
",",
"16",
")",
"next_byte",
"=",
"file_handle",
".",
"read",
"(",
"1",
")",
"if",
"(",
"next_byte",
"!=",
"' '",
")",
":",
"file_handle",
".",
"seek",
"(",
"header_length",
")",
"data",
"=",
"zlib",
".",
"decompress",
"(",
"file_handle",
".",
"read",
"(",
")",
",",
"15",
",",
"length",
")",
"assert",
"(",
"len",
"(",
"data",
")",
"==",
"length",
")",
",",
"(",
"'Incorrect data length while decompressing %s.The file could be corrupted.'",
"%",
"file_handle",
")",
"return",
"data"
] |
read the z-file and return the content as a string .
|
train
| false
|
14,049
|
def as_op(itypes, otypes, infer_shape=None):
if (not isinstance(itypes, (list, tuple))):
itypes = [itypes]
if any(((not isinstance(t, theano.Type)) for t in itypes)):
raise TypeError('itypes has to be a list of Theano types')
if (not isinstance(otypes, (list, tuple))):
otypes = [otypes]
if any(((not isinstance(t, theano.Type)) for t in otypes)):
raise TypeError('otypes has to be a list of Theano types')
itypes = list(itypes)
otypes = list(otypes)
if ((infer_shape is not None) and (not callable(infer_shape))):
raise TypeError('infer_shape needs to be a callable')
def make_op(fn):
return FromFunctionOp(fn, itypes, otypes, infer_shape)
return make_op
|
[
"def",
"as_op",
"(",
"itypes",
",",
"otypes",
",",
"infer_shape",
"=",
"None",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"itypes",
",",
"(",
"list",
",",
"tuple",
")",
")",
")",
":",
"itypes",
"=",
"[",
"itypes",
"]",
"if",
"any",
"(",
"(",
"(",
"not",
"isinstance",
"(",
"t",
",",
"theano",
".",
"Type",
")",
")",
"for",
"t",
"in",
"itypes",
")",
")",
":",
"raise",
"TypeError",
"(",
"'itypes has to be a list of Theano types'",
")",
"if",
"(",
"not",
"isinstance",
"(",
"otypes",
",",
"(",
"list",
",",
"tuple",
")",
")",
")",
":",
"otypes",
"=",
"[",
"otypes",
"]",
"if",
"any",
"(",
"(",
"(",
"not",
"isinstance",
"(",
"t",
",",
"theano",
".",
"Type",
")",
")",
"for",
"t",
"in",
"otypes",
")",
")",
":",
"raise",
"TypeError",
"(",
"'otypes has to be a list of Theano types'",
")",
"itypes",
"=",
"list",
"(",
"itypes",
")",
"otypes",
"=",
"list",
"(",
"otypes",
")",
"if",
"(",
"(",
"infer_shape",
"is",
"not",
"None",
")",
"and",
"(",
"not",
"callable",
"(",
"infer_shape",
")",
")",
")",
":",
"raise",
"TypeError",
"(",
"'infer_shape needs to be a callable'",
")",
"def",
"make_op",
"(",
"fn",
")",
":",
"return",
"FromFunctionOp",
"(",
"fn",
",",
"itypes",
",",
"otypes",
",",
"infer_shape",
")",
"return",
"make_op"
] |
decorator that converts a function into a basic theano op that will call the supplied function as its implementation .
|
train
| false
|
14,050
|
def metadef_resource_type_delete(context, resource_type_name, session=None):
session = (session or get_session())
return metadef_resource_type_api.delete(context, resource_type_name, session)
|
[
"def",
"metadef_resource_type_delete",
"(",
"context",
",",
"resource_type_name",
",",
"session",
"=",
"None",
")",
":",
"session",
"=",
"(",
"session",
"or",
"get_session",
"(",
")",
")",
"return",
"metadef_resource_type_api",
".",
"delete",
"(",
"context",
",",
"resource_type_name",
",",
"session",
")"
] |
get a resource_type .
|
train
| false
|
14,051
|
def MakeExponentialPmf(lam, high, n=200):
pmf = Pmf()
for x in np.linspace(0, high, n):
p = EvalExponentialPdf(x, lam)
pmf.Set(x, p)
pmf.Normalize()
return pmf
|
[
"def",
"MakeExponentialPmf",
"(",
"lam",
",",
"high",
",",
"n",
"=",
"200",
")",
":",
"pmf",
"=",
"Pmf",
"(",
")",
"for",
"x",
"in",
"np",
".",
"linspace",
"(",
"0",
",",
"high",
",",
"n",
")",
":",
"p",
"=",
"EvalExponentialPdf",
"(",
"x",
",",
"lam",
")",
"pmf",
".",
"Set",
"(",
"x",
",",
"p",
")",
"pmf",
".",
"Normalize",
"(",
")",
"return",
"pmf"
] |
makes a pmf discrete approx to an exponential distribution .
|
train
| true
|
14,052
|
def line_select_callback(eclick, erelease):
(x1, y1) = (eclick.xdata, eclick.ydata)
(x2, y2) = (erelease.xdata, erelease.ydata)
print(('(%3.2f, %3.2f) --> (%3.2f, %3.2f)' % (x1, y1, x2, y2)))
print((' The button you used were: %s %s' % (eclick.button, erelease.button)))
|
[
"def",
"line_select_callback",
"(",
"eclick",
",",
"erelease",
")",
":",
"(",
"x1",
",",
"y1",
")",
"=",
"(",
"eclick",
".",
"xdata",
",",
"eclick",
".",
"ydata",
")",
"(",
"x2",
",",
"y2",
")",
"=",
"(",
"erelease",
".",
"xdata",
",",
"erelease",
".",
"ydata",
")",
"print",
"(",
"(",
"'(%3.2f, %3.2f) --> (%3.2f, %3.2f)'",
"%",
"(",
"x1",
",",
"y1",
",",
"x2",
",",
"y2",
")",
")",
")",
"print",
"(",
"(",
"' The button you used were: %s %s'",
"%",
"(",
"eclick",
".",
"button",
",",
"erelease",
".",
"button",
")",
")",
")"
] |
eclick and erelease are the press and release events .
|
train
| false
|
14,054
|
def list_subscribers(t):
(owner, slug) = get_slug()
rel = {}
next_cursor = (-1)
while (next_cursor != 0):
m = t.lists.subscribers(slug=slug, owner_screen_name=owner, cursor=next_cursor, include_entities=False)
for u in m['users']:
rel[u['name']] = ('@' + u['screen_name'])
next_cursor = m['next_cursor']
printNicely((('All: ' + str(len(rel))) + ' subscribers.'))
for name in rel:
user = (' ' + cycle_color(name))
user += color_func(c['TWEET']['nick'])(((' ' + rel[name]) + ' '))
printNicely(user)
|
[
"def",
"list_subscribers",
"(",
"t",
")",
":",
"(",
"owner",
",",
"slug",
")",
"=",
"get_slug",
"(",
")",
"rel",
"=",
"{",
"}",
"next_cursor",
"=",
"(",
"-",
"1",
")",
"while",
"(",
"next_cursor",
"!=",
"0",
")",
":",
"m",
"=",
"t",
".",
"lists",
".",
"subscribers",
"(",
"slug",
"=",
"slug",
",",
"owner_screen_name",
"=",
"owner",
",",
"cursor",
"=",
"next_cursor",
",",
"include_entities",
"=",
"False",
")",
"for",
"u",
"in",
"m",
"[",
"'users'",
"]",
":",
"rel",
"[",
"u",
"[",
"'name'",
"]",
"]",
"=",
"(",
"'@'",
"+",
"u",
"[",
"'screen_name'",
"]",
")",
"next_cursor",
"=",
"m",
"[",
"'next_cursor'",
"]",
"printNicely",
"(",
"(",
"(",
"'All: '",
"+",
"str",
"(",
"len",
"(",
"rel",
")",
")",
")",
"+",
"' subscribers.'",
")",
")",
"for",
"name",
"in",
"rel",
":",
"user",
"=",
"(",
"' '",
"+",
"cycle_color",
"(",
"name",
")",
")",
"user",
"+=",
"color_func",
"(",
"c",
"[",
"'TWEET'",
"]",
"[",
"'nick'",
"]",
")",
"(",
"(",
"(",
"' '",
"+",
"rel",
"[",
"name",
"]",
")",
"+",
"' '",
")",
")",
"printNicely",
"(",
"user",
")"
] |
list subscribers .
|
train
| false
|
14,057
|
def read_bytes(urlpath, delimiter=None, not_zero=False, blocksize=(2 ** 27), sample=True, compression=None, **kwargs):
(fs, paths, myopen) = get_fs_paths_myopen(urlpath, compression, 'rb', None, **kwargs)
client = None
if (len(paths) == 0):
raise IOError(('%s resolved to no files' % urlpath))
(blocks, lengths, machines) = fs.get_block_locations(paths)
if blocks:
offsets = blocks
elif (blocksize is None):
offsets = ([[0]] * len(paths))
lengths = ([[None]] * len(offsets))
machines = ([[None]] * len(offsets))
else:
offsets = []
lengths = []
for path in paths:
try:
size = fs.logical_size(path, compression)
except KeyError:
raise ValueError(('Cannot read compressed files (%s) in byte chunks,use blocksize=None' % infer_compression(urlpath)))
off = list(range(0, size, blocksize))
length = ([blocksize] * len(off))
if not_zero:
off[0] = 1
length[0] -= 1
offsets.append(off)
lengths.append(length)
machines = ([[None]] * len(offsets))
out = []
for (path, offset, length, machine) in zip(paths, offsets, lengths, machines):
ukey = fs.ukey(path)
keys = [('read-block-%s-%s' % (o, tokenize(path, compression, offset, ukey, kwargs, delimiter))) for o in offset]
L = [delayed(read_block_from_file)(myopen(path, mode='rb'), o, l, delimiter, dask_key_name=key) for (o, key, l) in zip(offset, keys, length)]
out.append(L)
if (machine is not None):
if (client is None):
try:
from distributed.client import default_client
client = default_client()
except (ImportError, ValueError):
client = False
if client:
restrictions = {key: w for (key, w) in zip(keys, machine)}
client._send_to_scheduler({'op': 'update-graph', 'tasks': {}, 'dependencies': [], 'keys': [], 'restrictions': restrictions, 'loose_restrictions': list(restrictions), 'client': client.id})
if (sample is not True):
nbytes = sample
else:
nbytes = 10000
if sample:
with myopen(paths[0], 'rb') as f:
sample = read_block(f, 0, nbytes, delimiter)
return (sample, out)
|
[
"def",
"read_bytes",
"(",
"urlpath",
",",
"delimiter",
"=",
"None",
",",
"not_zero",
"=",
"False",
",",
"blocksize",
"=",
"(",
"2",
"**",
"27",
")",
",",
"sample",
"=",
"True",
",",
"compression",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"(",
"fs",
",",
"paths",
",",
"myopen",
")",
"=",
"get_fs_paths_myopen",
"(",
"urlpath",
",",
"compression",
",",
"'rb'",
",",
"None",
",",
"**",
"kwargs",
")",
"client",
"=",
"None",
"if",
"(",
"len",
"(",
"paths",
")",
"==",
"0",
")",
":",
"raise",
"IOError",
"(",
"(",
"'%s resolved to no files'",
"%",
"urlpath",
")",
")",
"(",
"blocks",
",",
"lengths",
",",
"machines",
")",
"=",
"fs",
".",
"get_block_locations",
"(",
"paths",
")",
"if",
"blocks",
":",
"offsets",
"=",
"blocks",
"elif",
"(",
"blocksize",
"is",
"None",
")",
":",
"offsets",
"=",
"(",
"[",
"[",
"0",
"]",
"]",
"*",
"len",
"(",
"paths",
")",
")",
"lengths",
"=",
"(",
"[",
"[",
"None",
"]",
"]",
"*",
"len",
"(",
"offsets",
")",
")",
"machines",
"=",
"(",
"[",
"[",
"None",
"]",
"]",
"*",
"len",
"(",
"offsets",
")",
")",
"else",
":",
"offsets",
"=",
"[",
"]",
"lengths",
"=",
"[",
"]",
"for",
"path",
"in",
"paths",
":",
"try",
":",
"size",
"=",
"fs",
".",
"logical_size",
"(",
"path",
",",
"compression",
")",
"except",
"KeyError",
":",
"raise",
"ValueError",
"(",
"(",
"'Cannot read compressed files (%s) in byte chunks,use blocksize=None'",
"%",
"infer_compression",
"(",
"urlpath",
")",
")",
")",
"off",
"=",
"list",
"(",
"range",
"(",
"0",
",",
"size",
",",
"blocksize",
")",
")",
"length",
"=",
"(",
"[",
"blocksize",
"]",
"*",
"len",
"(",
"off",
")",
")",
"if",
"not_zero",
":",
"off",
"[",
"0",
"]",
"=",
"1",
"length",
"[",
"0",
"]",
"-=",
"1",
"offsets",
".",
"append",
"(",
"off",
")",
"lengths",
".",
"append",
"(",
"length",
")",
"machines",
"=",
"(",
"[",
"[",
"None",
"]",
"]",
"*",
"len",
"(",
"offsets",
")",
")",
"out",
"=",
"[",
"]",
"for",
"(",
"path",
",",
"offset",
",",
"length",
",",
"machine",
")",
"in",
"zip",
"(",
"paths",
",",
"offsets",
",",
"lengths",
",",
"machines",
")",
":",
"ukey",
"=",
"fs",
".",
"ukey",
"(",
"path",
")",
"keys",
"=",
"[",
"(",
"'read-block-%s-%s'",
"%",
"(",
"o",
",",
"tokenize",
"(",
"path",
",",
"compression",
",",
"offset",
",",
"ukey",
",",
"kwargs",
",",
"delimiter",
")",
")",
")",
"for",
"o",
"in",
"offset",
"]",
"L",
"=",
"[",
"delayed",
"(",
"read_block_from_file",
")",
"(",
"myopen",
"(",
"path",
",",
"mode",
"=",
"'rb'",
")",
",",
"o",
",",
"l",
",",
"delimiter",
",",
"dask_key_name",
"=",
"key",
")",
"for",
"(",
"o",
",",
"key",
",",
"l",
")",
"in",
"zip",
"(",
"offset",
",",
"keys",
",",
"length",
")",
"]",
"out",
".",
"append",
"(",
"L",
")",
"if",
"(",
"machine",
"is",
"not",
"None",
")",
":",
"if",
"(",
"client",
"is",
"None",
")",
":",
"try",
":",
"from",
"distributed",
".",
"client",
"import",
"default_client",
"client",
"=",
"default_client",
"(",
")",
"except",
"(",
"ImportError",
",",
"ValueError",
")",
":",
"client",
"=",
"False",
"if",
"client",
":",
"restrictions",
"=",
"{",
"key",
":",
"w",
"for",
"(",
"key",
",",
"w",
")",
"in",
"zip",
"(",
"keys",
",",
"machine",
")",
"}",
"client",
".",
"_send_to_scheduler",
"(",
"{",
"'op'",
":",
"'update-graph'",
",",
"'tasks'",
":",
"{",
"}",
",",
"'dependencies'",
":",
"[",
"]",
",",
"'keys'",
":",
"[",
"]",
",",
"'restrictions'",
":",
"restrictions",
",",
"'loose_restrictions'",
":",
"list",
"(",
"restrictions",
")",
",",
"'client'",
":",
"client",
".",
"id",
"}",
")",
"if",
"(",
"sample",
"is",
"not",
"True",
")",
":",
"nbytes",
"=",
"sample",
"else",
":",
"nbytes",
"=",
"10000",
"if",
"sample",
":",
"with",
"myopen",
"(",
"paths",
"[",
"0",
"]",
",",
"'rb'",
")",
"as",
"f",
":",
"sample",
"=",
"read_block",
"(",
"f",
",",
"0",
",",
"nbytes",
",",
"delimiter",
")",
"return",
"(",
"sample",
",",
"out",
")"
] |
read tag data from file and return as byte string .
|
train
| false
|
14,058
|
def _GenerateAccessToken(action, tester, device_dict, auth_info_dict, user_cookie=None, use_short_token=True):
version = (message.MAX_SUPPORTED_MESSAGE_VERSION if use_short_token else message.Message.SUPPRESS_AUTH_NAME)
url = tester.GetUrl(('/%s/viewfinder' % action))
request_dict = auth_test._CreateRegisterRequest(device_dict, auth_info_dict, version=version)
response = auth_test._SendAuthRequest(tester, url, 'POST', user_cookie=user_cookie, request_dict=request_dict)
return json.loads(response.body)
|
[
"def",
"_GenerateAccessToken",
"(",
"action",
",",
"tester",
",",
"device_dict",
",",
"auth_info_dict",
",",
"user_cookie",
"=",
"None",
",",
"use_short_token",
"=",
"True",
")",
":",
"version",
"=",
"(",
"message",
".",
"MAX_SUPPORTED_MESSAGE_VERSION",
"if",
"use_short_token",
"else",
"message",
".",
"Message",
".",
"SUPPRESS_AUTH_NAME",
")",
"url",
"=",
"tester",
".",
"GetUrl",
"(",
"(",
"'/%s/viewfinder'",
"%",
"action",
")",
")",
"request_dict",
"=",
"auth_test",
".",
"_CreateRegisterRequest",
"(",
"device_dict",
",",
"auth_info_dict",
",",
"version",
"=",
"version",
")",
"response",
"=",
"auth_test",
".",
"_SendAuthRequest",
"(",
"tester",
",",
"url",
",",
"'POST'",
",",
"user_cookie",
"=",
"user_cookie",
",",
"request_dict",
"=",
"request_dict",
")",
"return",
"json",
".",
"loads",
"(",
"response",
".",
"body",
")"
] |
sends a request to the viewfinder auth service .
|
train
| false
|
14,059
|
def console_create(context, values):
return IMPL.console_create(context, values)
|
[
"def",
"console_create",
"(",
"context",
",",
"values",
")",
":",
"return",
"IMPL",
".",
"console_create",
"(",
"context",
",",
"values",
")"
] |
create a console .
|
train
| false
|
14,060
|
def ADXR(barDs, count, timeperiod=(- (2 ** 31))):
return call_talib_with_hlc(barDs, count, talib.ADXR, timeperiod)
|
[
"def",
"ADXR",
"(",
"barDs",
",",
"count",
",",
"timeperiod",
"=",
"(",
"-",
"(",
"2",
"**",
"31",
")",
")",
")",
":",
"return",
"call_talib_with_hlc",
"(",
"barDs",
",",
"count",
",",
"talib",
".",
"ADXR",
",",
"timeperiod",
")"
] |
average directional movement index rating .
|
train
| false
|
14,061
|
def _hash_internal(method, salt, password):
if (method == 'plain'):
return password
if salt:
if (method not in _hash_mods):
return None
if isinstance(salt, unicode):
salt = salt.encode('utf-8')
h = hmac.new(salt, None, _hash_mods[method])
else:
if (method not in _hash_funcs):
return None
h = _hash_funcs[method]()
if isinstance(password, unicode):
password = password.encode('utf-8')
h.update(password)
return h.hexdigest()
|
[
"def",
"_hash_internal",
"(",
"method",
",",
"salt",
",",
"password",
")",
":",
"if",
"(",
"method",
"==",
"'plain'",
")",
":",
"return",
"password",
"if",
"salt",
":",
"if",
"(",
"method",
"not",
"in",
"_hash_mods",
")",
":",
"return",
"None",
"if",
"isinstance",
"(",
"salt",
",",
"unicode",
")",
":",
"salt",
"=",
"salt",
".",
"encode",
"(",
"'utf-8'",
")",
"h",
"=",
"hmac",
".",
"new",
"(",
"salt",
",",
"None",
",",
"_hash_mods",
"[",
"method",
"]",
")",
"else",
":",
"if",
"(",
"method",
"not",
"in",
"_hash_funcs",
")",
":",
"return",
"None",
"h",
"=",
"_hash_funcs",
"[",
"method",
"]",
"(",
")",
"if",
"isinstance",
"(",
"password",
",",
"unicode",
")",
":",
"password",
"=",
"password",
".",
"encode",
"(",
"'utf-8'",
")",
"h",
".",
"update",
"(",
"password",
")",
"return",
"h",
".",
"hexdigest",
"(",
")"
] |
internal password hash helper .
|
train
| false
|
14,062
|
def polygonsOverlap(poly1, poly2):
try:
poly1 = poly1.verticesPix
except Exception:
pass
try:
poly2 = poly2.verticesPix
except Exception:
pass
if haveMatplotlib:
if (matplotlib.__version__ > '1.2'):
if any(mplPath(poly1).contains_points(poly2)):
return True
return any(mplPath(poly2).contains_points(poly1))
else:
try:
if any(nxutils.points_inside_poly(poly1, poly2)):
return True
return any(nxutils.points_inside_poly(poly2, poly1))
except Exception:
pass
for p1 in poly1:
if pointInPolygon(p1[0], p1[1], poly2):
return True
for p2 in poly2:
if pointInPolygon(p2[0], p2[1], poly1):
return True
return False
|
[
"def",
"polygonsOverlap",
"(",
"poly1",
",",
"poly2",
")",
":",
"try",
":",
"poly1",
"=",
"poly1",
".",
"verticesPix",
"except",
"Exception",
":",
"pass",
"try",
":",
"poly2",
"=",
"poly2",
".",
"verticesPix",
"except",
"Exception",
":",
"pass",
"if",
"haveMatplotlib",
":",
"if",
"(",
"matplotlib",
".",
"__version__",
">",
"'1.2'",
")",
":",
"if",
"any",
"(",
"mplPath",
"(",
"poly1",
")",
".",
"contains_points",
"(",
"poly2",
")",
")",
":",
"return",
"True",
"return",
"any",
"(",
"mplPath",
"(",
"poly2",
")",
".",
"contains_points",
"(",
"poly1",
")",
")",
"else",
":",
"try",
":",
"if",
"any",
"(",
"nxutils",
".",
"points_inside_poly",
"(",
"poly1",
",",
"poly2",
")",
")",
":",
"return",
"True",
"return",
"any",
"(",
"nxutils",
".",
"points_inside_poly",
"(",
"poly2",
",",
"poly1",
")",
")",
"except",
"Exception",
":",
"pass",
"for",
"p1",
"in",
"poly1",
":",
"if",
"pointInPolygon",
"(",
"p1",
"[",
"0",
"]",
",",
"p1",
"[",
"1",
"]",
",",
"poly2",
")",
":",
"return",
"True",
"for",
"p2",
"in",
"poly2",
":",
"if",
"pointInPolygon",
"(",
"p2",
"[",
"0",
"]",
",",
"p2",
"[",
"1",
"]",
",",
"poly1",
")",
":",
"return",
"True",
"return",
"False"
] |
determine if two polygons intersect; can fail for very pointy polygons .
|
train
| false
|
14,064
|
def _Pluralize(value, unused_context, args):
if (len(args) == 0):
(s, p) = ('', 's')
elif (len(args) == 1):
(s, p) = ('', args[0])
elif (len(args) == 2):
(s, p) = args
else:
raise AssertionError
if (value > 1):
return p
else:
return s
|
[
"def",
"_Pluralize",
"(",
"value",
",",
"unused_context",
",",
"args",
")",
":",
"if",
"(",
"len",
"(",
"args",
")",
"==",
"0",
")",
":",
"(",
"s",
",",
"p",
")",
"=",
"(",
"''",
",",
"'s'",
")",
"elif",
"(",
"len",
"(",
"args",
")",
"==",
"1",
")",
":",
"(",
"s",
",",
"p",
")",
"=",
"(",
"''",
",",
"args",
"[",
"0",
"]",
")",
"elif",
"(",
"len",
"(",
"args",
")",
"==",
"2",
")",
":",
"(",
"s",
",",
"p",
")",
"=",
"args",
"else",
":",
"raise",
"AssertionError",
"if",
"(",
"value",
">",
"1",
")",
":",
"return",
"p",
"else",
":",
"return",
"s"
] |
formatter to pluralize words .
|
train
| true
|
14,068
|
def backward(variables, grad_variables, retain_variables=False):
Variable._execution_engine.run_backward(tuple(variables), tuple(grad_variables), retain_variables)
|
[
"def",
"backward",
"(",
"variables",
",",
"grad_variables",
",",
"retain_variables",
"=",
"False",
")",
":",
"Variable",
".",
"_execution_engine",
".",
"run_backward",
"(",
"tuple",
"(",
"variables",
")",
",",
"tuple",
"(",
"grad_variables",
")",
",",
"retain_variables",
")"
] |
a generator returning lines from a file starting with the last line .
|
train
| false
|
14,069
|
@pytest.fixture
def app_stub(stubs):
stub = stubs.ApplicationStub()
objreg.register('app', stub)
(yield stub)
objreg.delete('app')
|
[
"@",
"pytest",
".",
"fixture",
"def",
"app_stub",
"(",
"stubs",
")",
":",
"stub",
"=",
"stubs",
".",
"ApplicationStub",
"(",
")",
"objreg",
".",
"register",
"(",
"'app'",
",",
"stub",
")",
"(",
"yield",
"stub",
")",
"objreg",
".",
"delete",
"(",
"'app'",
")"
] |
fixture which provides a fake app object .
|
train
| false
|
14,070
|
def requirement_args(argv, want_paths=False, want_other=False):
was_r = False
for arg in argv:
if was_r:
if want_paths:
(yield arg)
was_r = False
elif (arg in ['-r', '--requirement']):
was_r = True
elif want_other:
(yield arg)
|
[
"def",
"requirement_args",
"(",
"argv",
",",
"want_paths",
"=",
"False",
",",
"want_other",
"=",
"False",
")",
":",
"was_r",
"=",
"False",
"for",
"arg",
"in",
"argv",
":",
"if",
"was_r",
":",
"if",
"want_paths",
":",
"(",
"yield",
"arg",
")",
"was_r",
"=",
"False",
"elif",
"(",
"arg",
"in",
"[",
"'-r'",
",",
"'--requirement'",
"]",
")",
":",
"was_r",
"=",
"True",
"elif",
"want_other",
":",
"(",
"yield",
"arg",
")"
] |
return an iterable of filtered arguments .
|
train
| true
|
14,071
|
def generate_notification_email_unsubscribe_token(user_id36, user_email=None, user_password_hash=None):
import hashlib
import hmac
if ((not user_email) or (not user_password_hash)):
user = Account._byID36(user_id36, data=True)
if (not user_email):
user_email = user.email
if (not user_password_hash):
user_password_hash = user.password
return hmac.new(g.secrets['email_notifications'], ((user_id36 + user_email) + user_password_hash), hashlib.sha256).hexdigest()
|
[
"def",
"generate_notification_email_unsubscribe_token",
"(",
"user_id36",
",",
"user_email",
"=",
"None",
",",
"user_password_hash",
"=",
"None",
")",
":",
"import",
"hashlib",
"import",
"hmac",
"if",
"(",
"(",
"not",
"user_email",
")",
"or",
"(",
"not",
"user_password_hash",
")",
")",
":",
"user",
"=",
"Account",
".",
"_byID36",
"(",
"user_id36",
",",
"data",
"=",
"True",
")",
"if",
"(",
"not",
"user_email",
")",
":",
"user_email",
"=",
"user",
".",
"email",
"if",
"(",
"not",
"user_password_hash",
")",
":",
"user_password_hash",
"=",
"user",
".",
"password",
"return",
"hmac",
".",
"new",
"(",
"g",
".",
"secrets",
"[",
"'email_notifications'",
"]",
",",
"(",
"(",
"user_id36",
"+",
"user_email",
")",
"+",
"user_password_hash",
")",
",",
"hashlib",
".",
"sha256",
")",
".",
"hexdigest",
"(",
")"
] |
generate a token used for one-click unsubscribe links for notification emails .
|
train
| false
|
14,072
|
def test_no_targets():
skip_if_no_sklearn()
trainer = yaml_parse.load(test_yaml_no_targets)
trainer.main_loop()
|
[
"def",
"test_no_targets",
"(",
")",
":",
"skip_if_no_sklearn",
"(",
")",
"trainer",
"=",
"yaml_parse",
".",
"load",
"(",
"test_yaml_no_targets",
")",
"trainer",
".",
"main_loop",
"(",
")"
] |
test cross-validation without targets .
|
train
| false
|
14,073
|
def dumpPacket(buffer):
return repr([hex(x) for x in buffer])
|
[
"def",
"dumpPacket",
"(",
"buffer",
")",
":",
"return",
"repr",
"(",
"[",
"hex",
"(",
"x",
")",
"for",
"x",
"in",
"buffer",
"]",
")"
] |
name: dumppacket args: byte array desc: returns hex value of all bytes in the buffer .
|
train
| false
|
14,074
|
@pytest.mark.django_db
def test_image_plugin_choice_widget_get_object():
image = File.objects.create()
widget = ImagePluginChoiceWidget()
assert (widget.get_object(image.pk) == image)
assert (widget.get_object(1000) == None)
|
[
"@",
"pytest",
".",
"mark",
".",
"django_db",
"def",
"test_image_plugin_choice_widget_get_object",
"(",
")",
":",
"image",
"=",
"File",
".",
"objects",
".",
"create",
"(",
")",
"widget",
"=",
"ImagePluginChoiceWidget",
"(",
")",
"assert",
"(",
"widget",
".",
"get_object",
"(",
"image",
".",
"pk",
")",
"==",
"image",
")",
"assert",
"(",
"widget",
".",
"get_object",
"(",
"1000",
")",
"==",
"None",
")"
] |
test get_object method for imagepluginchoicewidget .
|
train
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.