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 |
|---|---|---|---|---|---|
3,487 | def _api_pause_pp(name, output, kwargs):
PostProcessor.do.paused = True
return report(output)
| [
"def",
"_api_pause_pp",
"(",
"name",
",",
"output",
",",
"kwargs",
")",
":",
"PostProcessor",
".",
"do",
".",
"paused",
"=",
"True",
"return",
"report",
"(",
"output",
")"
] | api: accepts output . | train | false |
3,488 | def tuple_key(tup):
def generator():
for item in tup:
try:
(yield (1, int(item)))
except ValueError:
(yield (0, item))
return tuple(generator())
| [
"def",
"tuple_key",
"(",
"tup",
")",
":",
"def",
"generator",
"(",
")",
":",
"for",
"item",
"in",
"tup",
":",
"try",
":",
"(",
"yield",
"(",
"1",
",",
"int",
"(",
"item",
")",
")",
")",
"except",
"ValueError",
":",
"(",
"yield",
"(",
"0",
",",
... | return a sort key for mixed int/string tuples . | train | false |
3,489 | def choose_task_name(app_name, queue_name, user_chosen=None):
if (not user_chosen):
user_chosen = _get_random_string()
return ('task_%s_%s_%s' % (app_name, queue_name, user_chosen))
| [
"def",
"choose_task_name",
"(",
"app_name",
",",
"queue_name",
",",
"user_chosen",
"=",
"None",
")",
":",
"if",
"(",
"not",
"user_chosen",
")",
":",
"user_chosen",
"=",
"_get_random_string",
"(",
")",
"return",
"(",
"'task_%s_%s_%s'",
"%",
"(",
"app_name",
"... | creates a task name that the system can use to address tasks from different apps and queues . | train | false |
3,490 | def _clean_tags(tags):
def clean(tagstr):
if isinstance(tagstr, str):
return tagstr.replace('|', '_')[:200]
return unicode(tagstr).replace('|', '_')[:200].encode('utf-8')
return [clean(t) for t in tags]
| [
"def",
"_clean_tags",
"(",
"tags",
")",
":",
"def",
"clean",
"(",
"tagstr",
")",
":",
"if",
"isinstance",
"(",
"tagstr",
",",
"str",
")",
":",
"return",
"tagstr",
".",
"replace",
"(",
"'|'",
",",
"'_'",
")",
"[",
":",
"200",
"]",
"return",
"unicode... | helper method that does the actual cleaning of tags for sending to statsd . | train | false |
3,492 | def list_recursively(dir):
if (not _os.path.isdir(dir)):
raise ValueError, ('%s is not a directory.' % dir)
for f in _os.listdir(dir):
if _os.path.isdir(f):
list_recursively(f)
else:
(yield f)
| [
"def",
"list_recursively",
"(",
"dir",
")",
":",
"if",
"(",
"not",
"_os",
".",
"path",
".",
"isdir",
"(",
"dir",
")",
")",
":",
"raise",
"ValueError",
",",
"(",
"'%s is not a directory.'",
"%",
"dir",
")",
"for",
"f",
"in",
"_os",
".",
"listdir",
"("... | recursively list the contents of a directory . | train | false |
3,494 | def make_html_patterns():
tags = any('builtin', ['<', '[\\?/]?>', '(?<=<).*?(?=[ >])'])
keywords = any('keyword', [' [\\w:-]*?(?==)'])
string = any('string', ['".*?"'])
comment = any('comment', ['<!--.*?-->'])
multiline_comment_start = any('multiline_comment_start', ['<!--'])
multiline_comment_end = any('multiline_comment_end', ['-->'])
return '|'.join([comment, multiline_comment_start, multiline_comment_end, tags, keywords, string])
| [
"def",
"make_html_patterns",
"(",
")",
":",
"tags",
"=",
"any",
"(",
"'builtin'",
",",
"[",
"'<'",
",",
"'[\\\\?/]?>'",
",",
"'(?<=<).*?(?=[ >])'",
"]",
")",
"keywords",
"=",
"any",
"(",
"'keyword'",
",",
"[",
"' [\\\\w:-]*?(?==)'",
"]",
")",
"string",
"="... | strongly inspired from idlelib . | train | false |
3,495 | def unpack_bitstr(rev_cur_bit, bitstr):
bstr_len = len(bitstr)
return ''.join([rev_cur_bit[bitstr[i:(i + 2)]] for i in range(0, bstr_len, 2)])
| [
"def",
"unpack_bitstr",
"(",
"rev_cur_bit",
",",
"bitstr",
")",
":",
"bstr_len",
"=",
"len",
"(",
"bitstr",
")",
"return",
"''",
".",
"join",
"(",
"[",
"rev_cur_bit",
"[",
"bitstr",
"[",
"i",
":",
"(",
"i",
"+",
"2",
")",
"]",
"]",
"for",
"i",
"i... | unpack bistring into nt sequence . | train | false |
3,496 | def _inflate_g(g, n):
def inflate(params, n):
' (a1, .., ak) -> (a1/n, (a1+1)/n, ..., (ak + n-1)/n) '
res = []
for a in params:
for i in range(n):
res.append(((a + i) / n))
return res
v = S((len(g.ap) - len(g.bq)))
C = (n ** ((1 + g.nu) + (v / 2)))
C /= ((2 * pi) ** ((n - 1) * g.delta))
return (C, meijerg(inflate(g.an, n), inflate(g.aother, n), inflate(g.bm, n), inflate(g.bother, n), ((g.argument ** n) * (n ** (n * v)))))
| [
"def",
"_inflate_g",
"(",
"g",
",",
"n",
")",
":",
"def",
"inflate",
"(",
"params",
",",
"n",
")",
":",
"res",
"=",
"[",
"]",
"for",
"a",
"in",
"params",
":",
"for",
"i",
"in",
"range",
"(",
"n",
")",
":",
"res",
".",
"append",
"(",
"(",
"(... | return c . | train | false |
3,497 | @app.route('/_add_numbers')
def add_numbers():
a = request.args.get('a', 0, type=int)
b = request.args.get('b', 0, type=int)
return jsonify(result=(a + b))
| [
"@",
"app",
".",
"route",
"(",
"'/_add_numbers'",
")",
"def",
"add_numbers",
"(",
")",
":",
"a",
"=",
"request",
".",
"args",
".",
"get",
"(",
"'a'",
",",
"0",
",",
"type",
"=",
"int",
")",
"b",
"=",
"request",
".",
"args",
".",
"get",
"(",
"'b... | add two numbers server side . | train | false |
3,498 | @contextmanager
def signals_disabled(qobject):
old_state = qobject.signalsBlocked()
qobject.blockSignals(True)
try:
(yield)
finally:
qobject.blockSignals(old_state)
| [
"@",
"contextmanager",
"def",
"signals_disabled",
"(",
"qobject",
")",
":",
"old_state",
"=",
"qobject",
".",
"signalsBlocked",
"(",
")",
"qobject",
".",
"blockSignals",
"(",
"True",
")",
"try",
":",
"(",
"yield",
")",
"finally",
":",
"qobject",
".",
"bloc... | disables signals on an instance of qobject . | train | false |
3,499 | def varcorrection_pairs_unbalanced(nobs_all, srange=False):
(n1, n2) = np.meshgrid(nobs_all, nobs_all)
if (not srange):
return ((1.0 / n1) + (1.0 / n2))
else:
return (((1.0 / n1) + (1.0 / n2)) / 2.0)
| [
"def",
"varcorrection_pairs_unbalanced",
"(",
"nobs_all",
",",
"srange",
"=",
"False",
")",
":",
"(",
"n1",
",",
"n2",
")",
"=",
"np",
".",
"meshgrid",
"(",
"nobs_all",
",",
"nobs_all",
")",
"if",
"(",
"not",
"srange",
")",
":",
"return",
"(",
"(",
"... | correction factor for variance with unequal sample sizes for all pairs this is just a harmonic mean parameters nobs_all : array_like the number of observations for each sample srange : bool if true . | train | false |
3,500 | def _millis(when):
micros = _microseconds_from_datetime(when)
return (micros // 1000)
| [
"def",
"_millis",
"(",
"when",
")",
":",
"micros",
"=",
"_microseconds_from_datetime",
"(",
"when",
")",
"return",
"(",
"micros",
"//",
"1000",
")"
] | convert a zone-aware datetime to integer milliseconds . | train | false |
3,503 | def hankel(c, r=None):
c = np.asarray(c).ravel()
if (r is None):
r = np.zeros_like(c)
else:
r = np.asarray(r).ravel()
vals = np.concatenate((c, r[1:]))
(a, b) = np.ogrid[0:len(c), 0:len(r)]
indx = (a + b)
return vals[indx]
| [
"def",
"hankel",
"(",
"c",
",",
"r",
"=",
"None",
")",
":",
"c",
"=",
"np",
".",
"asarray",
"(",
"c",
")",
".",
"ravel",
"(",
")",
"if",
"(",
"r",
"is",
"None",
")",
":",
"r",
"=",
"np",
".",
"zeros_like",
"(",
"c",
")",
"else",
":",
"r",... | construct a hankel matrix . | train | false |
3,506 | def _unify_gens(f_gens, g_gens):
f_gens = list(f_gens)
g_gens = list(g_gens)
if (f_gens == g_gens):
return tuple(f_gens)
(gens, common, k) = ([], [], 0)
for gen in f_gens:
if (gen in g_gens):
common.append(gen)
for (i, gen) in enumerate(g_gens):
if (gen in common):
(g_gens[i], k) = (common[k], (k + 1))
for gen in common:
i = f_gens.index(gen)
gens.extend(f_gens[:i])
f_gens = f_gens[(i + 1):]
i = g_gens.index(gen)
gens.extend(g_gens[:i])
g_gens = g_gens[(i + 1):]
gens.append(gen)
gens.extend(f_gens)
gens.extend(g_gens)
return tuple(gens)
| [
"def",
"_unify_gens",
"(",
"f_gens",
",",
"g_gens",
")",
":",
"f_gens",
"=",
"list",
"(",
"f_gens",
")",
"g_gens",
"=",
"list",
"(",
"g_gens",
")",
"if",
"(",
"f_gens",
"==",
"g_gens",
")",
":",
"return",
"tuple",
"(",
"f_gens",
")",
"(",
"gens",
"... | unify generators in a reasonably intelligent way . | train | false |
3,508 | def maximum_line_length(physical_line):
length = len(physical_line.rstrip())
if (length > 79):
return (79, ('E501 line too long (%d characters)' % length))
| [
"def",
"maximum_line_length",
"(",
"physical_line",
")",
":",
"length",
"=",
"len",
"(",
"physical_line",
".",
"rstrip",
"(",
")",
")",
"if",
"(",
"length",
">",
"79",
")",
":",
"return",
"(",
"79",
",",
"(",
"'E501 line too long (%d characters)'",
"%",
"l... | limit all lines to a maximum of 79 characters . | train | false |
3,509 | def mv(src_path, dest_path):
try:
os.rename(src_path, dest_path)
except OSError:
os.remove(dest_path)
os.rename(src_path, dest_path)
| [
"def",
"mv",
"(",
"src_path",
",",
"dest_path",
")",
":",
"try",
":",
"os",
".",
"rename",
"(",
"src_path",
",",
"dest_path",
")",
"except",
"OSError",
":",
"os",
".",
"remove",
"(",
"dest_path",
")",
"os",
".",
"rename",
"(",
"src_path",
",",
"dest_... | a shell-like mv . | train | false |
3,514 | @slicer.after_request
def add_cors_headers(response):
origin = current_app.slicer.allow_cors_origin
if (origin and len(origin)):
if (request.method == 'OPTIONS'):
response.headers['Access-Control-Allow-Headers'] = 'X-Requested-With'
if (origin == '*'):
response.headers['Access-Control-Allow-Origin'] = request.headers.get('Origin', origin)
else:
response.headers['Access-Control-Allow-Origin'] = origin
response.headers['Access-Control-Allow-Credentials'] = 'true'
response.headers['Access-Control-Allow-Methods'] = 'GET, POST, OPTIONS'
response.headers['Access-Control-Max-Age'] = CORS_MAX_AGE
return response
| [
"@",
"slicer",
".",
"after_request",
"def",
"add_cors_headers",
"(",
"response",
")",
":",
"origin",
"=",
"current_app",
".",
"slicer",
".",
"allow_cors_origin",
"if",
"(",
"origin",
"and",
"len",
"(",
"origin",
")",
")",
":",
"if",
"(",
"request",
".",
... | add cross-origin resource sharing headers . | train | false |
3,515 | def _urlunsplit(scheme=None, netloc=None, path=None, query=None, fragment=None):
if ((not scheme) or (not netloc)):
scheme = None
netloc = None
if path:
path = urllib.quote(_to_utf8(path))
if (query and (not isinstance(query, basestring))):
if isinstance(query, dict):
query = query.iteritems()
query = urllib.urlencode(sorted(query))
if fragment:
fragment = urllib.quote(_to_utf8(fragment))
return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
| [
"def",
"_urlunsplit",
"(",
"scheme",
"=",
"None",
",",
"netloc",
"=",
"None",
",",
"path",
"=",
"None",
",",
"query",
"=",
"None",
",",
"fragment",
"=",
"None",
")",
":",
"if",
"(",
"(",
"not",
"scheme",
")",
"or",
"(",
"not",
"netloc",
")",
")",... | like urlparse . | train | false |
3,516 | def run_correlation_test(data_generator, test, test_choices, pval_assignment_method, permutations=None):
(corr_coefs, pvals) = ([], [])
test_fn = test_choices[test]
for (otu_vals, md_vals) in data_generator:
r = test_fn(otu_vals, md_vals)
if (pval_assignment_method == 'bootstrapped'):
pval = assign_correlation_pval(r, len(otu_vals), pval_assignment_method, permutations, test_fn, otu_vals, md_vals)
else:
pval = assign_correlation_pval(r, len(otu_vals), pval_assignment_method)
corr_coefs.append(r)
pvals.append(pval)
return (corr_coefs, pvals)
| [
"def",
"run_correlation_test",
"(",
"data_generator",
",",
"test",
",",
"test_choices",
",",
"pval_assignment_method",
",",
"permutations",
"=",
"None",
")",
":",
"(",
"corr_coefs",
",",
"pvals",
")",
"=",
"(",
"[",
"]",
",",
"[",
"]",
")",
"test_fn",
"=",... | run correlation tests . | train | false |
3,517 | def getMsPerFrame(myWin, nFrames=60, showVisual=False, msg='', msDelay=0.0):
return myWin.getMsPerFrame(nFrames=60, showVisual=showVisual, msg=msg, msDelay=0.0)
| [
"def",
"getMsPerFrame",
"(",
"myWin",
",",
"nFrames",
"=",
"60",
",",
"showVisual",
"=",
"False",
",",
"msg",
"=",
"''",
",",
"msDelay",
"=",
"0.0",
")",
":",
"return",
"myWin",
".",
"getMsPerFrame",
"(",
"nFrames",
"=",
"60",
",",
"showVisual",
"=",
... | deprecated: please use the getmsperframe method in the psychopy . | train | false |
3,518 | def chuang_f3(individual):
total = 0
if (individual[(-1)] == 0):
for i in xrange(0, (len(individual) - 1), 4):
total += inv_trap(individual[i:(i + 4)])
else:
for i in xrange(2, (len(individual) - 3), 4):
total += inv_trap(individual[i:(i + 4)])
total += trap((individual[(-2):] + individual[:2]))
return (total,)
| [
"def",
"chuang_f3",
"(",
"individual",
")",
":",
"total",
"=",
"0",
"if",
"(",
"individual",
"[",
"(",
"-",
"1",
")",
"]",
"==",
"0",
")",
":",
"for",
"i",
"in",
"xrange",
"(",
"0",
",",
"(",
"len",
"(",
"individual",
")",
"-",
"1",
")",
",",... | binary deceptive function from : multivariate multi-model approach for globally multimodal problems by chung-yao chuang and wen-lian hsu . | train | false |
3,519 | def parse_storage_string(value):
byte_multipliers = {u'K': 1024, u'M': 1048576, u'G': 1073741824, u'T': 1099511627776}
if (not isinstance(value, types.StringTypes)):
raise ValueError(u'Value must be string, got {type}.'.format(type=type(value).__name__))
pattern = re.compile(u'^(\\d+\\.?\\d*)(K|M|G|T)?$', (re.I | re.U))
parsed = pattern.match(value)
if (not parsed):
raise ValueError(u"Value '{value}' could not be parsed as a storage quantity.".format(value=value))
(quantity, unit) = parsed.groups()
quantity = float(quantity)
if (unit is not None):
unit = unit.upper()
quantity = (quantity * byte_multipliers[unit])
quantity = int(math.ceil(quantity))
return quantity
| [
"def",
"parse_storage_string",
"(",
"value",
")",
":",
"byte_multipliers",
"=",
"{",
"u'K'",
":",
"1024",
",",
"u'M'",
":",
"1048576",
",",
"u'G'",
":",
"1073741824",
",",
"u'T'",
":",
"1099511627776",
"}",
"if",
"(",
"not",
"isinstance",
"(",
"value",
"... | converts a string representing a quantity and a unit identifier in to an integer value representing the number of bytes in that quantity . | train | false |
3,522 | def find_web_xml(app_name):
app_dir = '/var/apps/{}/app'.format(app_name)
file_name = 'appengine-web.xml'
matches = []
for (root, dirs, files) in os.walk(app_dir):
if ((file_name in files) and root.endswith('/WEB-INF')):
matches.append(os.path.join(root, file_name))
if (len(matches) < 1):
raise BadConfigurationException('Unable to find {} file for {}'.format(file_name, app_name))
if (len(matches) > 1):
matches.sort()
match_to_use = matches[0]
for match in matches:
if (len(match) < len(match_to_use)):
match_to_use = match
return match_to_use
return matches[0]
| [
"def",
"find_web_xml",
"(",
"app_name",
")",
":",
"app_dir",
"=",
"'/var/apps/{}/app'",
".",
"format",
"(",
"app_name",
")",
"file_name",
"=",
"'appengine-web.xml'",
"matches",
"=",
"[",
"]",
"for",
"(",
"root",
",",
"dirs",
",",
"files",
")",
"in",
"os",
... | returns the location of a java applications appengine-web . | train | false |
3,524 | def help_option(*param_decls, **attrs):
def decorator(f):
def callback(ctx, param, value):
if (value and (not ctx.resilient_parsing)):
echo(ctx.get_help(), color=ctx.color)
ctx.exit()
attrs.setdefault('is_flag', True)
attrs.setdefault('expose_value', False)
attrs.setdefault('help', 'Show this message and exit.')
attrs.setdefault('is_eager', True)
attrs['callback'] = callback
return option(*(param_decls or ('--help',)), **attrs)(f)
return decorator
| [
"def",
"help_option",
"(",
"*",
"param_decls",
",",
"**",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"def",
"callback",
"(",
"ctx",
",",
"param",
",",
"value",
")",
":",
"if",
"(",
"value",
"and",
"(",
"not",
"ctx",
".",
"resilient_... | adds a --help option which immediately ends the program printing out the help page . | train | true |
3,525 | def need_ext():
sys.stdout.write('{0}\next_mods\n'.format(OPTIONS.delimiter))
sys.exit(EX_MOD_DEPLOY)
| [
"def",
"need_ext",
"(",
")",
":",
"sys",
".",
"stdout",
".",
"write",
"(",
"'{0}\\next_mods\\n'",
".",
"format",
"(",
"OPTIONS",
".",
"delimiter",
")",
")",
"sys",
".",
"exit",
"(",
"EX_MOD_DEPLOY",
")"
] | signal that external modules need to be deployed . | train | true |
3,526 | def extract_filters(term, opts=None):
opts = (opts or {})
filters = {}
params = {}
(term, addon_type) = extract_from_query(term, 'type', '\\w+')
addon_type = (addon_type or opts.get('addon_type'))
if addon_type:
try:
atype = int(addon_type)
if (atype in amo.ADDON_SEARCH_TYPES):
filters['type'] = atype
except ValueError:
atype = amo.ADDON_SEARCH_SLUGS.get(addon_type.lower())
if atype:
filters['type'] = atype
(term, platform) = extract_from_query(term, 'platform', '\\w+')
params['platform'] = (platform or opts.get('platform'))
(term, version) = extract_from_query(term, 'version', '[0-9.]+')
params['version'] = (version or opts.get('version'))
(term, tag) = extract_from_query(term, 'tag', '\\w+')
if tag:
tag = Tag.objects.filter(tag_text=tag).values_list('tag_text', flat=True)
if tag:
filters['tags__in'] = list(tag)
return (term, filters, params)
| [
"def",
"extract_filters",
"(",
"term",
",",
"opts",
"=",
"None",
")",
":",
"opts",
"=",
"(",
"opts",
"or",
"{",
"}",
")",
"filters",
"=",
"{",
"}",
"params",
"=",
"{",
"}",
"(",
"term",
",",
"addon_type",
")",
"=",
"extract_from_query",
"(",
"term"... | pulls all the filtering options out of the term and returns a cleaned term and a dictionary of filter names and filter values . | train | false |
3,527 | def _scale_mpl_figure(fig, scale):
fig.set_size_inches((fig.get_size_inches() * scale))
fig.set_dpi((fig.get_dpi() * scale))
import matplotlib as mpl
if (scale >= 1):
sfactor = (scale ** 2)
elif (scale < 1):
sfactor = (- ((1.0 / scale) ** 2))
for text in fig.findobj(mpl.text.Text):
fs = text.get_fontsize()
new_size = (fs + sfactor)
if (new_size <= 0):
raise ValueError('could not rescale matplotlib fonts, consider increasing "scale"')
text.set_fontsize(new_size)
fig.canvas.draw()
| [
"def",
"_scale_mpl_figure",
"(",
"fig",
",",
"scale",
")",
":",
"fig",
".",
"set_size_inches",
"(",
"(",
"fig",
".",
"get_size_inches",
"(",
")",
"*",
"scale",
")",
")",
"fig",
".",
"set_dpi",
"(",
"(",
"fig",
".",
"get_dpi",
"(",
")",
"*",
"scale",
... | magic scaling helper . | train | false |
3,529 | def specific_iterator(qs):
pks_and_types = qs.values_list(u'pk', u'content_type')
pks_by_type = defaultdict(list)
for (pk, content_type) in pks_and_types:
pks_by_type[content_type].append(pk)
content_types = {pk: ContentType.objects.get_for_id(pk) for (_, pk) in pks_and_types}
pages_by_type = {}
for (content_type, pks) in pks_by_type.items():
model = content_types[content_type].model_class()
pages = model.objects.filter(pk__in=pks)
pages_by_type[content_type] = {page.pk: page for page in pages}
for (pk, content_type) in pks_and_types:
(yield pages_by_type[content_type][pk])
| [
"def",
"specific_iterator",
"(",
"qs",
")",
":",
"pks_and_types",
"=",
"qs",
".",
"values_list",
"(",
"u'pk'",
",",
"u'content_type'",
")",
"pks_by_type",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"(",
"pk",
",",
"content_type",
")",
"in",
"pks_and_types"... | this efficiently iterates all the specific pages in a queryset . | train | false |
3,530 | def flush_rttable(rt_table):
if (rt_table in ['local', 'main', 'default']):
return
run(settings.ip, 'route', 'flush', 'table', rt_table)
| [
"def",
"flush_rttable",
"(",
"rt_table",
")",
":",
"if",
"(",
"rt_table",
"in",
"[",
"'local'",
",",
"'main'",
",",
"'default'",
"]",
")",
":",
"return",
"run",
"(",
"settings",
".",
"ip",
",",
"'route'",
",",
"'flush'",
",",
"'table'",
",",
"rt_table"... | flushes specified routing table entries . | train | false |
3,531 | def validate_hook(shell_cmd, hook_name):
if shell_cmd:
cmd = shell_cmd.split(None, 1)[0]
if (not _prog(cmd)):
path = os.environ['PATH']
msg = 'Unable to find {2}-hook command {0} in the PATH.\n(PATH is {1})'.format(cmd, path, hook_name)
raise errors.HookCommandNotFound(msg)
| [
"def",
"validate_hook",
"(",
"shell_cmd",
",",
"hook_name",
")",
":",
"if",
"shell_cmd",
":",
"cmd",
"=",
"shell_cmd",
".",
"split",
"(",
"None",
",",
"1",
")",
"[",
"0",
"]",
"if",
"(",
"not",
"_prog",
"(",
"cmd",
")",
")",
":",
"path",
"=",
"os... | check that a command provided as a hook is plausibly executable . | train | false |
3,532 | @library.filter
def round_percent(num):
return (round(num, 1) if (num < 10) else int(round(num, 0)))
| [
"@",
"library",
".",
"filter",
"def",
"round_percent",
"(",
"num",
")",
":",
"return",
"(",
"round",
"(",
"num",
",",
"1",
")",
"if",
"(",
"num",
"<",
"10",
")",
"else",
"int",
"(",
"round",
"(",
"num",
",",
"0",
")",
")",
")"
] | return a customercare-format percentage from a number . | train | false |
3,534 | def relative_wildcard_glob(dirname, pattern):
if (not dirname):
dirname = os.curdir
try:
if ('**' in pattern):
names = list(_iter_relative_dirs(dirname))
else:
names = os.listdir(dirname)
except OSError:
return []
result = []
pattern = os.path.normcase(pattern)
match = re.compile(translate(pattern)).match
for name in names:
if match(os.path.normcase(name)):
result.append(name)
return result
| [
"def",
"relative_wildcard_glob",
"(",
"dirname",
",",
"pattern",
")",
":",
"if",
"(",
"not",
"dirname",
")",
":",
"dirname",
"=",
"os",
".",
"curdir",
"try",
":",
"if",
"(",
"'**'",
"in",
"pattern",
")",
":",
"names",
"=",
"list",
"(",
"_iter_relative_... | non-recursive glob for one directory . | train | false |
3,535 | def _compute_signature(parameters, access_key_secret):
def percent_encode(line):
if (not isinstance(line, str)):
return line
s = line
if (sys.stdin.encoding is None):
s = line.decode().encode('utf8')
else:
s = line.decode(sys.stdin.encoding).encode('utf8')
res = _quote(s, '')
res = res.replace('+', '%20')
res = res.replace('*', '%2A')
res = res.replace('%7E', '~')
return res
sortedParameters = sorted(list(parameters.items()), key=(lambda items: items[0]))
canonicalizedQueryString = ''
for (k, v) in sortedParameters:
canonicalizedQueryString += ((('&' + percent_encode(k)) + '=') + percent_encode(v))
stringToSign = ('GET&%2F&' + percent_encode(canonicalizedQueryString[1:]))
h = hmac.new((access_key_secret + '&'), stringToSign, sha1)
signature = base64.encodestring(h.digest()).strip()
return signature
| [
"def",
"_compute_signature",
"(",
"parameters",
",",
"access_key_secret",
")",
":",
"def",
"percent_encode",
"(",
"line",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"line",
",",
"str",
")",
")",
":",
"return",
"line",
"s",
"=",
"line",
"if",
"(",
"... | generate an api request signature . | train | true |
3,537 | def _theano_single_leapfrog(H, q, p, **theano_kwargs):
epsilon = tt.dscalar('epsilon')
epsilon.tag.test_value = 1
p_new = (p + ((0.5 * epsilon) * H.dlogp(q)))
q_new = (q + (epsilon * H.pot.velocity(p_new)))
p_new += ((0.5 * epsilon) * H.dlogp(q_new))
energy_new = energy(H, q_new, p_new)
f = theano.function(inputs=[q, p, epsilon], outputs=[q_new, p_new, energy_new], **theano_kwargs)
f.trust_input = True
return f
| [
"def",
"_theano_single_leapfrog",
"(",
"H",
",",
"q",
",",
"p",
",",
"**",
"theano_kwargs",
")",
":",
"epsilon",
"=",
"tt",
".",
"dscalar",
"(",
"'epsilon'",
")",
"epsilon",
".",
"tag",
".",
"test_value",
"=",
"1",
"p_new",
"=",
"(",
"p",
"+",
"(",
... | leapfrog integrator for a single step . | train | false |
3,539 | def stopcron():
global _cron_stopping
_cron_stopping = True
while _cron_subprocs:
proc = _cron_subprocs.pop()
if (proc.poll() is None):
try:
proc.terminate()
except:
import traceback
traceback.print_exc()
| [
"def",
"stopcron",
"(",
")",
":",
"global",
"_cron_stopping",
"_cron_stopping",
"=",
"True",
"while",
"_cron_subprocs",
":",
"proc",
"=",
"_cron_subprocs",
".",
"pop",
"(",
")",
"if",
"(",
"proc",
".",
"poll",
"(",
")",
"is",
"None",
")",
":",
"try",
"... | graceful shutdown of cron . | train | false |
3,540 | def to_id(s):
if (s == '+'):
return 11
if (s == '*'):
return 12
return (int(s) + 1)
| [
"def",
"to_id",
"(",
"s",
")",
":",
"if",
"(",
"s",
"==",
"'+'",
")",
":",
"return",
"11",
"if",
"(",
"s",
"==",
"'*'",
")",
":",
"return",
"12",
"return",
"(",
"int",
"(",
"s",
")",
"+",
"1",
")"
] | covert text to ids . | train | false |
3,541 | def _add_loss_summaries(total_loss):
loss_averages = tf.train.ExponentialMovingAverage(0.9, name='avg')
losses = tf.get_collection('losses')
loss_averages_op = loss_averages.apply((losses + [total_loss]))
for l in (losses + [total_loss]):
tf.summary.scalar((l.op.name + ' (raw)'), l)
tf.summary.scalar(l.op.name, loss_averages.average(l))
return loss_averages_op
| [
"def",
"_add_loss_summaries",
"(",
"total_loss",
")",
":",
"loss_averages",
"=",
"tf",
".",
"train",
".",
"ExponentialMovingAverage",
"(",
"0.9",
",",
"name",
"=",
"'avg'",
")",
"losses",
"=",
"tf",
".",
"get_collection",
"(",
"'losses'",
")",
"loss_averages_o... | add summaries for losses in cifar-10 model . | train | true |
3,542 | def get_foreign_module(namespace):
if (namespace not in _MODULES):
try:
module = importlib.import_module(('.' + namespace), __package__)
except ImportError:
module = None
_MODULES[namespace] = module
module = _MODULES.get(namespace)
if (module is None):
raise ForeignError(('Foreign %r structs not supported' % namespace))
return module
| [
"def",
"get_foreign_module",
"(",
"namespace",
")",
":",
"if",
"(",
"namespace",
"not",
"in",
"_MODULES",
")",
":",
"try",
":",
"module",
"=",
"importlib",
".",
"import_module",
"(",
"(",
"'.'",
"+",
"namespace",
")",
",",
"__package__",
")",
"except",
"... | returns the module or raises foreignerror . | train | true |
3,543 | def do_setup():
root = get_root()
try:
cfg = get_config_from_root(root)
except (EnvironmentError, configparser.NoSectionError, configparser.NoOptionError) as e:
if isinstance(e, (EnvironmentError, configparser.NoSectionError)):
print('Adding sample versioneer config to setup.cfg', file=sys.stderr)
with open(os.path.join(root, 'setup.cfg'), 'a') as f:
f.write(SAMPLE_CONFIG)
print(CONFIG_ERROR, file=sys.stderr)
return 1
print((' creating %s' % cfg.versionfile_source))
with open(cfg.versionfile_source, 'w') as f:
LONG = LONG_VERSION_PY[cfg.VCS]
f.write((LONG % {'DOLLAR': '$', 'STYLE': cfg.style, 'TAG_PREFIX': cfg.tag_prefix, 'PARENTDIR_PREFIX': cfg.parentdir_prefix, 'VERSIONFILE_SOURCE': cfg.versionfile_source}))
ipy = os.path.join(os.path.dirname(cfg.versionfile_source), '__init__.py')
if os.path.exists(ipy):
try:
with open(ipy, 'r') as f:
old = f.read()
except EnvironmentError:
old = ''
if (INIT_PY_SNIPPET not in old):
print((' appending to %s' % ipy))
with open(ipy, 'a') as f:
f.write(INIT_PY_SNIPPET)
else:
print((' %s unmodified' % ipy))
else:
print((" %s doesn't exist, ok" % ipy))
ipy = None
manifest_in = os.path.join(root, 'MANIFEST.in')
simple_includes = set()
try:
with open(manifest_in, 'r') as f:
for line in f:
if line.startswith('include '):
for include in line.split()[1:]:
simple_includes.add(include)
except EnvironmentError:
pass
if ('versioneer.py' not in simple_includes):
print(" appending 'versioneer.py' to MANIFEST.in")
with open(manifest_in, 'a') as f:
f.write('include versioneer.py\n')
else:
print(" 'versioneer.py' already in MANIFEST.in")
if (cfg.versionfile_source not in simple_includes):
print((" appending versionfile_source ('%s') to MANIFEST.in" % cfg.versionfile_source))
with open(manifest_in, 'a') as f:
f.write(('include %s\n' % cfg.versionfile_source))
else:
print(' versionfile_source already in MANIFEST.in')
do_vcs_install(manifest_in, cfg.versionfile_source, ipy)
return 0
| [
"def",
"do_setup",
"(",
")",
":",
"root",
"=",
"get_root",
"(",
")",
"try",
":",
"cfg",
"=",
"get_config_from_root",
"(",
"root",
")",
"except",
"(",
"EnvironmentError",
",",
"configparser",
".",
"NoSectionError",
",",
"configparser",
".",
"NoOptionError",
"... | run the setup after we have everything configured . | train | true |
3,544 | def build_database():
if snapshot:
uc = upgrade_code_snapshot
else:
uc = upgrade_code
if msilib.Win64:
productsuffix = ' (64-bit)'
else:
productsuffix = ''
db = msilib.init_database(('python-%s%s.msi' % (full_current_version, msilib.arch_ext)), schema, ProductName=(('Python ' + full_current_version) + productsuffix), ProductCode=product_code, ProductVersion=current_version, Manufacturer=u'Python Software Foundation', request_uac=True)
msilib.change_sequence(sequence.InstallExecuteSequence, 'RemoveExistingProducts', 1510)
msilib.add_tables(db, sequence)
add_data(db, 'Property', [('UpgradeCode', uc), ('WhichUsers', 'ALL'), ('ProductLine', ('Python%s%s' % (major, minor)))])
db.Commit()
return db
| [
"def",
"build_database",
"(",
")",
":",
"if",
"snapshot",
":",
"uc",
"=",
"upgrade_code_snapshot",
"else",
":",
"uc",
"=",
"upgrade_code",
"if",
"msilib",
".",
"Win64",
":",
"productsuffix",
"=",
"' (64-bit)'",
"else",
":",
"productsuffix",
"=",
"''",
"db",
... | generate an empty database . | train | false |
3,545 | @utils.arg('host', metavar='<hostname>', help=_('Name of host.'))
@utils.arg('binary', metavar='<binary>', help=_('Service binary.'))
def do_service_enable(cs, args):
result = cs.services.enable(args.host, args.binary)
utils.print_list([result], ['Host', 'Binary', 'Status'])
| [
"@",
"utils",
".",
"arg",
"(",
"'host'",
",",
"metavar",
"=",
"'<hostname>'",
",",
"help",
"=",
"_",
"(",
"'Name of host.'",
")",
")",
"@",
"utils",
".",
"arg",
"(",
"'binary'",
",",
"metavar",
"=",
"'<binary>'",
",",
"help",
"=",
"_",
"(",
"'Service... | enable the service . | train | false |
3,548 | @register.filter
def has_permissions(user, component):
return user.has_perms(getattr(component, 'permissions', set()))
| [
"@",
"register",
".",
"filter",
"def",
"has_permissions",
"(",
"user",
",",
"component",
")",
":",
"return",
"user",
".",
"has_perms",
"(",
"getattr",
"(",
"component",
",",
"'permissions'",
",",
"set",
"(",
")",
")",
")"
] | checks if the given user meets the permissions requirements for the component . | train | false |
3,549 | @scope.define_pure
def idxs_take(idxs, vals, which):
assert (len(idxs) == len(vals))
table = dict(list(zip(idxs, vals)))
return np.asarray([table[w] for w in which])
| [
"@",
"scope",
".",
"define_pure",
"def",
"idxs_take",
"(",
"idxs",
",",
"vals",
",",
"which",
")",
":",
"assert",
"(",
"len",
"(",
"idxs",
")",
"==",
"len",
"(",
"vals",
")",
")",
"table",
"=",
"dict",
"(",
"list",
"(",
"zip",
"(",
"idxs",
",",
... | return vals[which] where which is a subset of idxs . | train | false |
3,550 | def SGD_final_layer(self, training_data, epochs, mini_batch_size, eta, lmbda):
encoded_training_data = [(self.feedforward(x, start=0, end=(self.num_layers - 2)), y) for (x, y) in training_data]
net = Network(self.sizes[(-2):])
net.biases[0] = self.biases[(-1)]
net.weights[0] = self.weights[(-1)]
net.SGD(encoded_training_data, epochs, mini_batch_size, eta, lmbda)
self.biases[(-1)] = net.biases[0]
self.weights[(-1)] = net.weights[0]
| [
"def",
"SGD_final_layer",
"(",
"self",
",",
"training_data",
",",
"epochs",
",",
"mini_batch_size",
",",
"eta",
",",
"lmbda",
")",
":",
"encoded_training_data",
"=",
"[",
"(",
"self",
".",
"feedforward",
"(",
"x",
",",
"start",
"=",
"0",
",",
"end",
"=",... | run sgd on the final layer of the network self . | train | false |
3,551 | def _tan1(p, x, prec):
R = p.ring
p1 = R(0)
for precx in _giant_steps(prec):
tmp = (p - rs_atan(p1, x, precx))
tmp = rs_mul(tmp, (1 + rs_square(p1, x, precx)), x, precx)
p1 += tmp
return p1
| [
"def",
"_tan1",
"(",
"p",
",",
"x",
",",
"prec",
")",
":",
"R",
"=",
"p",
".",
"ring",
"p1",
"=",
"R",
"(",
"0",
")",
"for",
"precx",
"in",
"_giant_steps",
"(",
"prec",
")",
":",
"tmp",
"=",
"(",
"p",
"-",
"rs_atan",
"(",
"p1",
",",
"x",
... | helper function of rs_tan . | train | false |
3,552 | def get_view(request):
return HttpResponse('Hello world')
| [
"def",
"get_view",
"(",
"request",
")",
":",
"return",
"HttpResponse",
"(",
"'Hello world'",
")"
] | a simple login protected view . | train | false |
3,554 | def some_action(post):
print post['created_time']
| [
"def",
"some_action",
"(",
"post",
")",
":",
"print",
"post",
"[",
"'created_time'",
"]"
] | here you might want to do something with each post . | train | false |
3,556 | def testopendocx():
if isinstance(opendocx(TEST_FILE), lxml.etree._Element):
pass
else:
assert False
| [
"def",
"testopendocx",
"(",
")",
":",
"if",
"isinstance",
"(",
"opendocx",
"(",
"TEST_FILE",
")",
",",
"lxml",
".",
"etree",
".",
"_Element",
")",
":",
"pass",
"else",
":",
"assert",
"False"
] | ensure an etree element is returned . | train | false |
3,557 | def runNetwork(network, writer):
sensorRegion = network.regions['sensor']
spatialPoolerRegion = network.regions['spatialPoolerRegion']
temporalPoolerRegion = network.regions['temporalPoolerRegion']
anomalyLikelihoodRegion = network.regions['anomalyLikelihoodRegion']
prevPredictedColumns = []
for i in xrange(_NUM_RECORDS):
network.run(1)
consumption = sensorRegion.getOutputData('sourceOut')[0]
anomalyScore = temporalPoolerRegion.getOutputData('anomalyScore')[0]
anomalyLikelihood = anomalyLikelihoodRegion.getOutputData('anomalyLikelihood')[0]
writer.writerow((i, consumption, anomalyScore, anomalyLikelihood))
| [
"def",
"runNetwork",
"(",
"network",
",",
"writer",
")",
":",
"sensorRegion",
"=",
"network",
".",
"regions",
"[",
"'sensor'",
"]",
"spatialPoolerRegion",
"=",
"network",
".",
"regions",
"[",
"'spatialPoolerRegion'",
"]",
"temporalPoolerRegion",
"=",
"network",
... | run the network and write output to writer . | train | true |
3,558 | def remove_extension(template):
return template[:(- len('.template'))]
| [
"def",
"remove_extension",
"(",
"template",
")",
":",
"return",
"template",
"[",
":",
"(",
"-",
"len",
"(",
"'.template'",
")",
")",
"]"
] | remove download or media extension from name . | train | false |
3,559 | @require_context
def volume_get_all_active_by_window(context, begin, end=None, project_id=None):
query = model_query(context, models.Volume, read_deleted='yes')
query = query.filter(or_((models.Volume.deleted_at == None), (models.Volume.deleted_at > begin)))
if end:
query = query.filter((models.Volume.created_at < end))
if project_id:
query = query.filter_by(project_id=project_id)
query = query.options(joinedload('volume_metadata')).options(joinedload('volume_type')).options(joinedload('volume_attachment')).options(joinedload('consistencygroup')).options(joinedload('group'))
if is_admin_context(context):
query = query.options(joinedload('volume_admin_metadata'))
return query.all()
| [
"@",
"require_context",
"def",
"volume_get_all_active_by_window",
"(",
"context",
",",
"begin",
",",
"end",
"=",
"None",
",",
"project_id",
"=",
"None",
")",
":",
"query",
"=",
"model_query",
"(",
"context",
",",
"models",
".",
"Volume",
",",
"read_deleted",
... | get all the volumes inside the window . | train | false |
3,560 | def cache_property(key, empty, type):
return property((lambda x: x._get_cache_value(key, empty, type)), (lambda x, v: x._set_cache_value(key, v, type)), (lambda x: x._del_cache_value(key)), ('accessor for %r' % key))
| [
"def",
"cache_property",
"(",
"key",
",",
"empty",
",",
"type",
")",
":",
"return",
"property",
"(",
"(",
"lambda",
"x",
":",
"x",
".",
"_get_cache_value",
"(",
"key",
",",
"empty",
",",
"type",
")",
")",
",",
"(",
"lambda",
"x",
",",
"v",
":",
"... | return a new property object for a cache header . | train | true |
3,563 | def filter_partition_list(partitions, devnames):
filtered_list = []
for p in partitions:
for d in devnames:
if ((p.device == d) and (p not in filtered_list)):
filtered_list.append(p)
return filtered_list
| [
"def",
"filter_partition_list",
"(",
"partitions",
",",
"devnames",
")",
":",
"filtered_list",
"=",
"[",
"]",
"for",
"p",
"in",
"partitions",
":",
"for",
"d",
"in",
"devnames",
":",
"if",
"(",
"(",
"p",
".",
"device",
"==",
"d",
")",
"and",
"(",
"p",... | pick and choose which partition to keep . | train | false |
3,564 | def active_contributors(from_date, to_date=None, locale=None, product=None):
return User.objects.filter(id__in=_active_contributors_id(from_date, to_date, locale, product)).order_by('username')
| [
"def",
"active_contributors",
"(",
"from_date",
",",
"to_date",
"=",
"None",
",",
"locale",
"=",
"None",
",",
"product",
"=",
"None",
")",
":",
"return",
"User",
".",
"objects",
".",
"filter",
"(",
"id__in",
"=",
"_active_contributors_id",
"(",
"from_date",
... | return active kb contributors for the specified parameters . | train | false |
3,566 | def only_squares(*matrices):
if (matrices[0].rows != matrices[(-1)].cols):
raise RuntimeError('Invalid matrices being multiplied')
out = []
start = 0
for (i, M) in enumerate(matrices):
if (M.cols == matrices[start].rows):
out.append(MatMul(*matrices[start:(i + 1)]).doit())
start = (i + 1)
return out
| [
"def",
"only_squares",
"(",
"*",
"matrices",
")",
":",
"if",
"(",
"matrices",
"[",
"0",
"]",
".",
"rows",
"!=",
"matrices",
"[",
"(",
"-",
"1",
")",
"]",
".",
"cols",
")",
":",
"raise",
"RuntimeError",
"(",
"'Invalid matrices being multiplied'",
")",
"... | factor matrices only if they are square . | train | false |
3,567 | def compute_eta(start_time, current_value, final_value):
elapsed = (time.time() - start_time)
completion = ((float(current_value) / final_value) or 1e-05)
return get_time_units((((1.0 / completion) * elapsed) - elapsed))
| [
"def",
"compute_eta",
"(",
"start_time",
",",
"current_value",
",",
"final_value",
")",
":",
"elapsed",
"=",
"(",
"time",
".",
"time",
"(",
")",
"-",
"start_time",
")",
"completion",
"=",
"(",
"(",
"float",
"(",
"current_value",
")",
"/",
"final_value",
... | compute an eta . | train | false |
3,571 | def fdatasync(fd):
try:
os.fdatasync(fd)
except AttributeError:
fsync(fd)
| [
"def",
"fdatasync",
"(",
"fd",
")",
":",
"try",
":",
"os",
".",
"fdatasync",
"(",
"fd",
")",
"except",
"AttributeError",
":",
"fsync",
"(",
"fd",
")"
] | sync modified file data to disk . | train | false |
3,572 | def registerNamespaceAlias(namespace_uri, alias):
global registered_aliases
if (registered_aliases.get(alias) == namespace_uri):
return
if (namespace_uri in registered_aliases.values()):
raise NamespaceAliasRegistrationError, ('Namespace uri %r already registered' % (namespace_uri,))
if (alias in registered_aliases):
raise NamespaceAliasRegistrationError, ('Alias %r already registered' % (alias,))
registered_aliases[alias] = namespace_uri
| [
"def",
"registerNamespaceAlias",
"(",
"namespace_uri",
",",
"alias",
")",
":",
"global",
"registered_aliases",
"if",
"(",
"registered_aliases",
".",
"get",
"(",
"alias",
")",
"==",
"namespace_uri",
")",
":",
"return",
"if",
"(",
"namespace_uri",
"in",
"registere... | registers a mapping in a global namespace alias map . | train | true |
3,573 | def _should_include_path(path, includes, excludes):
from os.path import basename
from fnmatch import fnmatch
base = basename(path)
if includes:
for include in includes:
if fnmatch(base, include):
try:
log.debug("include `%s' (matches `%s')", path, include)
except (NameError, AttributeError):
pass
break
else:
try:
log.debug("exclude `%s' (matches no includes)", path)
except (NameError, AttributeError):
pass
return False
for exclude in excludes:
if fnmatch(base, exclude):
try:
log.debug("exclude `%s' (matches `%s')", path, exclude)
except (NameError, AttributeError):
pass
return False
return True
| [
"def",
"_should_include_path",
"(",
"path",
",",
"includes",
",",
"excludes",
")",
":",
"from",
"os",
".",
"path",
"import",
"basename",
"from",
"fnmatch",
"import",
"fnmatch",
"base",
"=",
"basename",
"(",
"path",
")",
"if",
"includes",
":",
"for",
"inclu... | return true iff the given path should be included . | train | false |
3,575 | def libvlc_vlm_set_loop(p_instance, psz_name, b_loop):
f = (_Cfunctions.get('libvlc_vlm_set_loop', None) or _Cfunction('libvlc_vlm_set_loop', ((1,), (1,), (1,)), None, ctypes.c_int, Instance, ctypes.c_char_p, ctypes.c_int))
return f(p_instance, psz_name, b_loop)
| [
"def",
"libvlc_vlm_set_loop",
"(",
"p_instance",
",",
"psz_name",
",",
"b_loop",
")",
":",
"f",
"=",
"(",
"_Cfunctions",
".",
"get",
"(",
"'libvlc_vlm_set_loop'",
",",
"None",
")",
"or",
"_Cfunction",
"(",
"'libvlc_vlm_set_loop'",
",",
"(",
"(",
"1",
",",
... | set a medias loop status . | train | true |
3,578 | @contextmanager
def check_environ(unset=True):
with mock.patch.dict(os.environ):
old_fds = os.environ.get('LISTEN_FDS', None)
old_pid = os.environ.get('LISTEN_PID', None)
(yield)
if unset:
assert ('LISTEN_FDS' not in os.environ), 'LISTEN_FDS should have been unset'
assert ('LISTEN_PID' not in os.environ), 'LISTEN_PID should have been unset'
else:
new_fds = os.environ.get('LISTEN_FDS', None)
new_pid = os.environ.get('LISTEN_PID', None)
assert (new_fds == old_fds), 'LISTEN_FDS should not have been changed'
assert (new_pid == old_pid), 'LISTEN_PID should not have been changed'
| [
"@",
"contextmanager",
"def",
"check_environ",
"(",
"unset",
"=",
"True",
")",
":",
"with",
"mock",
".",
"patch",
".",
"dict",
"(",
"os",
".",
"environ",
")",
":",
"old_fds",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'LISTEN_FDS'",
",",
"None",
")... | ensure that os . | train | false |
3,580 | def show_name_details(book, name, show_contents=0, f=sys.stdout):
name_lcase = name.lower()
nobj_list = book.name_map.get(name_lcase)
if (not nobj_list):
print(('%r: unknown name' % name), file=f)
return
for nobj in nobj_list:
show_name_object(book, nobj, show_contents, f)
| [
"def",
"show_name_details",
"(",
"book",
",",
"name",
",",
"show_contents",
"=",
"0",
",",
"f",
"=",
"sys",
".",
"stdout",
")",
":",
"name_lcase",
"=",
"name",
".",
"lower",
"(",
")",
"nobj_list",
"=",
"book",
".",
"name_map",
".",
"get",
"(",
"name_... | book -- book object obtained from xlrd . | train | false |
3,581 | def parse_server(server_string):
host = DefaultHost
port = DefaultPort
if ((server_string != None) and (server_string.find(':') == (-1))):
host = server_string
elif (server_string != None):
(host, port) = server_string.split(':', 1)
return (socket.gethostbyname(host), int(port))
| [
"def",
"parse_server",
"(",
"server_string",
")",
":",
"host",
"=",
"DefaultHost",
"port",
"=",
"DefaultPort",
"if",
"(",
"(",
"server_string",
"!=",
"None",
")",
"and",
"(",
"server_string",
".",
"find",
"(",
"':'",
")",
"==",
"(",
"-",
"1",
")",
")",... | decode the server endpoint parameters . | train | false |
3,582 | def _swap(f, i):
ring = f.ring
k = ring.ngens
fswap = ring.zero
for (monom, coeff) in f.iterterms():
monomswap = (((monom[i],) + monom[:i]) + monom[(i + 1):])
fswap[monomswap] = coeff
return fswap
| [
"def",
"_swap",
"(",
"f",
",",
"i",
")",
":",
"ring",
"=",
"f",
".",
"ring",
"k",
"=",
"ring",
".",
"ngens",
"fswap",
"=",
"ring",
".",
"zero",
"for",
"(",
"monom",
",",
"coeff",
")",
"in",
"f",
".",
"iterterms",
"(",
")",
":",
"monomswap",
"... | make the variable x_i the leading one in a multivariate polynomial f . | train | false |
3,583 | def countby(key, seq):
if (not callable(key)):
key = getter(key)
return frequencies(map(key, seq))
| [
"def",
"countby",
"(",
"key",
",",
"seq",
")",
":",
"if",
"(",
"not",
"callable",
"(",
"key",
")",
")",
":",
"key",
"=",
"getter",
"(",
"key",
")",
"return",
"frequencies",
"(",
"map",
"(",
"key",
",",
"seq",
")",
")"
] | count elements of a collection by a key function . | train | false |
3,584 | def get_markup_filter_name():
name = get_markup_filter()[0]
return ('html' if (name is None) else name)
| [
"def",
"get_markup_filter_name",
"(",
")",
":",
"name",
"=",
"get_markup_filter",
"(",
")",
"[",
"0",
"]",
"return",
"(",
"'html'",
"if",
"(",
"name",
"is",
"None",
")",
"else",
"name",
")"
] | returns the current markup filters name . | train | false |
3,585 | def send_alert(request, message=None, url=None, code='soft-eol'):
if (url is None):
url = request.registry.settings['project_docs']
request.response.headers['Alert'] = encode_header(json.dumps({'code': code, 'message': message, 'url': url}))
| [
"def",
"send_alert",
"(",
"request",
",",
"message",
"=",
"None",
",",
"url",
"=",
"None",
",",
"code",
"=",
"'soft-eol'",
")",
":",
"if",
"(",
"url",
"is",
"None",
")",
":",
"url",
"=",
"request",
".",
"registry",
".",
"settings",
"[",
"'project_doc... | this sends an email alert . | train | false |
3,588 | def make_valuation(concepts, read=False, lexicon=False):
vals = []
for c in concepts:
vals.append((c.prefLabel, c.extension))
if lexicon:
read = True
if read:
from nltk.sem import Valuation
val = Valuation({})
val.update(vals)
val = label_indivs(val, lexicon=lexicon)
return val
else:
return vals
| [
"def",
"make_valuation",
"(",
"concepts",
",",
"read",
"=",
"False",
",",
"lexicon",
"=",
"False",
")",
":",
"vals",
"=",
"[",
"]",
"for",
"c",
"in",
"concepts",
":",
"vals",
".",
"append",
"(",
"(",
"c",
".",
"prefLabel",
",",
"c",
".",
"extension... | convert a list of concept objects into a list of pairs; optionally create a valuation object . | train | false |
3,589 | def put_lifecycle_configuration(Bucket, Rules, region=None, key=None, keyid=None, profile=None):
try:
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if ((Rules is not None) and isinstance(Rules, six.string_types)):
Rules = json.loads(Rules)
conn.put_bucket_lifecycle_configuration(Bucket=Bucket, LifecycleConfiguration={'Rules': Rules})
return {'updated': True, 'name': Bucket}
except ClientError as e:
return {'updated': False, 'error': __utils__['boto3.get_error'](e)}
| [
"def",
"put_lifecycle_configuration",
"(",
"Bucket",
",",
"Rules",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"try",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
"=",
"region"... | given a valid config . | train | true |
3,590 | def _wrapx(input, output, repeat):
output[...] = 0
nbytes = (((repeat - 1) // 8) + 1)
unused = ((nbytes * 8) - repeat)
for i in range(nbytes):
_min = (i * 8)
_max = min(((i + 1) * 8), repeat)
for j in range(_min, _max):
if (j != _min):
np.left_shift(output[..., i], 1, output[..., i])
np.add(output[..., i], input[..., j], output[..., i])
np.left_shift(output[..., i], unused, output[..., i])
| [
"def",
"_wrapx",
"(",
"input",
",",
"output",
",",
"repeat",
")",
":",
"output",
"[",
"...",
"]",
"=",
"0",
"nbytes",
"=",
"(",
"(",
"(",
"repeat",
"-",
"1",
")",
"//",
"8",
")",
"+",
"1",
")",
"unused",
"=",
"(",
"(",
"nbytes",
"*",
"8",
"... | wrap the x format column boolean array into an uint8 array . | train | false |
3,592 | def ValidateVfsPath(path):
components = (path or '').lstrip('/').split('/')
if (not components):
raise ValueError(('Empty path is not a valid path: %s.' % utils.SmartStr(path)))
if (components[0] not in ROOT_FILES_WHITELIST):
raise ValueError(("First path component was '%s', but has to be one of %s" % (utils.SmartStr(components[0]), ', '.join(ROOT_FILES_WHITELIST))))
return True
| [
"def",
"ValidateVfsPath",
"(",
"path",
")",
":",
"components",
"=",
"(",
"path",
"or",
"''",
")",
".",
"lstrip",
"(",
"'/'",
")",
".",
"split",
"(",
"'/'",
")",
"if",
"(",
"not",
"components",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'Empty path i... | validates a vfs path . | train | true |
3,593 | @validate('form')
def valid_type_in_colspan(arch):
return all((attrib.isdigit() for attrib in arch.xpath('//@colspan')))
| [
"@",
"validate",
"(",
"'form'",
")",
"def",
"valid_type_in_colspan",
"(",
"arch",
")",
":",
"return",
"all",
"(",
"(",
"attrib",
".",
"isdigit",
"(",
")",
"for",
"attrib",
"in",
"arch",
".",
"xpath",
"(",
"'//@colspan'",
")",
")",
")"
] | a colspan attribute must be an integer type . | train | false |
3,594 | def gf_irred_p_rabin(f, p, K):
n = gf_degree(f)
if (n <= 1):
return True
(_, f) = gf_monic(f, p, K)
x = [K.one, K.zero]
indices = {(n // d) for d in factorint(n)}
b = gf_frobenius_monomial_base(f, p, K)
h = b[1]
for i in range(1, n):
if (i in indices):
g = gf_sub(h, x, p, K)
if (gf_gcd(f, g, p, K) != [K.one]):
return False
h = gf_frobenius_map(h, f, b, p, K)
return (h == x)
| [
"def",
"gf_irred_p_rabin",
"(",
"f",
",",
"p",
",",
"K",
")",
":",
"n",
"=",
"gf_degree",
"(",
"f",
")",
"if",
"(",
"n",
"<=",
"1",
")",
":",
"return",
"True",
"(",
"_",
",",
"f",
")",
"=",
"gf_monic",
"(",
"f",
",",
"p",
",",
"K",
")",
"... | rabins polynomial irreducibility test over finite fields . | train | false |
3,595 | def gen3():
for i in (0, 1, 2):
(yield i)
| [
"def",
"gen3",
"(",
")",
":",
"for",
"i",
"in",
"(",
"0",
",",
"1",
",",
"2",
")",
":",
"(",
"yield",
"i",
")"
] | non-restartable source sequence . | train | false |
3,597 | def def_unit(s, represents=None, doc=None, format=None, prefixes=False, exclude_prefixes=[], namespace=None):
if (represents is not None):
result = Unit(s, represents, namespace=namespace, doc=doc, format=format)
else:
result = IrreducibleUnit(s, namespace=namespace, doc=doc, format=format)
if prefixes:
_add_prefixes(result, excludes=exclude_prefixes, namespace=namespace, prefixes=prefixes)
return result
| [
"def",
"def_unit",
"(",
"s",
",",
"represents",
"=",
"None",
",",
"doc",
"=",
"None",
",",
"format",
"=",
"None",
",",
"prefixes",
"=",
"False",
",",
"exclude_prefixes",
"=",
"[",
"]",
",",
"namespace",
"=",
"None",
")",
":",
"if",
"(",
"represents",... | factory function for defining new units . | train | false |
3,598 | def create_pipeline(name, unique_id, description='', region=None, key=None, keyid=None, profile=None):
client = _get_client(region, key, keyid, profile)
r = {}
try:
response = client.create_pipeline(name=name, uniqueId=unique_id, description=description)
r['result'] = response['pipelineId']
except (botocore.exceptions.BotoCoreError, botocore.exceptions.ClientError) as e:
r['error'] = str(e)
return r
| [
"def",
"create_pipeline",
"(",
"name",
",",
"unique_id",
",",
"description",
"=",
"''",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"client",
"=",
"_get_client",
"(",
"region",
... | create a new . | train | true |
3,599 | def config_gen(dic):
sio = StringIO()
print >>sio, '<?xml version="1.0" encoding="UTF-8"?>'
print >>sio, '<configuration>'
for (k, v) in dic.iteritems():
print >>sio, ('<property>\n <name>%s</name>\n <value><![CDATA[%s]]></value>\n</property>\n' % (escape(k), (v.replace(']]>', '') if isinstance(v, basestring) else v)))
print >>sio, '</configuration>'
sio.flush()
sio.seek(0)
return sio.read()
| [
"def",
"config_gen",
"(",
"dic",
")",
":",
"sio",
"=",
"StringIO",
"(",
")",
"print",
">>",
"sio",
",",
"'<?xml version=\"1.0\" encoding=\"UTF-8\"?>'",
"print",
">>",
"sio",
",",
"'<configuration>'",
"for",
"(",
"k",
",",
"v",
")",
"in",
"dic",
".",
"iteri... | config_gen -> xml for oozie workflow configuration . | train | false |
3,600 | def balanced_eq(want, to_balance):
expander = ForParser(to_balance)
eq_(want, expander.to_unicode())
| [
"def",
"balanced_eq",
"(",
"want",
",",
"to_balance",
")",
":",
"expander",
"=",
"ForParser",
"(",
"to_balance",
")",
"eq_",
"(",
"want",
",",
"expander",
".",
"to_unicode",
"(",
")",
")"
] | run to_balance through the expander to get its tags balanced . | train | false |
3,602 | def makeelement(tagname, tagtext=None, nsprefix='w', attributes=None, attrnsprefix=None):
namespacemap = None
if isinstance(nsprefix, list):
namespacemap = {}
for prefix in nsprefix:
namespacemap[prefix] = nsprefixes[prefix]
nsprefix = nsprefix[0]
if nsprefix:
namespace = ('{%s}' % nsprefixes[nsprefix])
else:
namespace = ''
newelement = etree.Element((namespace + tagname), nsmap=namespacemap)
if attributes:
if (not attrnsprefix):
if (nsprefix == 'w'):
attributenamespace = namespace
else:
attributenamespace = ''
else:
attributenamespace = (('{' + nsprefixes[attrnsprefix]) + '}')
for tagattribute in attributes:
newelement.set((attributenamespace + tagattribute), attributes[tagattribute])
if tagtext:
newelement.text = tagtext
return newelement
| [
"def",
"makeelement",
"(",
"tagname",
",",
"tagtext",
"=",
"None",
",",
"nsprefix",
"=",
"'w'",
",",
"attributes",
"=",
"None",
",",
"attrnsprefix",
"=",
"None",
")",
":",
"namespacemap",
"=",
"None",
"if",
"isinstance",
"(",
"nsprefix",
",",
"list",
")"... | create an element & return it . | train | true |
3,603 | def get_mock_hdfs_root(environ=None):
return get_mock_dir('hdfs', environ=environ)
| [
"def",
"get_mock_hdfs_root",
"(",
"environ",
"=",
"None",
")",
":",
"return",
"get_mock_dir",
"(",
"'hdfs'",
",",
"environ",
"=",
"environ",
")"
] | get the path of mock root of hdfs . | train | false |
3,604 | def get_mirrors(hostname=None):
if (hostname is None):
hostname = DEFAULT_MIRROR_URL
try:
hostname = socket.gethostbyname_ex(hostname)[0]
except socket.gaierror:
return []
end_letter = hostname.split('.', 1)
return [('%s.%s' % (s, end_letter[1])) for s in string_range(end_letter[0])]
| [
"def",
"get_mirrors",
"(",
"hostname",
"=",
"None",
")",
":",
"if",
"(",
"hostname",
"is",
"None",
")",
":",
"hostname",
"=",
"DEFAULT_MIRROR_URL",
"try",
":",
"hostname",
"=",
"socket",
".",
"gethostbyname_ex",
"(",
"hostname",
")",
"[",
"0",
"]",
"exce... | get a repository mirror list from gitosis . | train | true |
3,605 | def is_safe_for_update(block_device_dict):
fields = set(block_device_dict.keys())
return (fields <= ((bdm_new_fields | bdm_db_inherited_fields) | bdm_db_only_fields))
| [
"def",
"is_safe_for_update",
"(",
"block_device_dict",
")",
":",
"fields",
"=",
"set",
"(",
"block_device_dict",
".",
"keys",
"(",
")",
")",
"return",
"(",
"fields",
"<=",
"(",
"(",
"bdm_new_fields",
"|",
"bdm_db_inherited_fields",
")",
"|",
"bdm_db_only_fields"... | determine if passed dict is a safe subset for update . | train | false |
3,606 | def clone_get_equiv(inputs, outputs, copy_inputs_and_orphans=True, memo=None):
if (memo is None):
memo = {}
for input in inputs:
if copy_inputs_and_orphans:
cpy = input.clone()
cpy.owner = None
cpy.index = None
memo.setdefault(input, cpy)
else:
memo.setdefault(input, input)
for apply in io_toposort(inputs, outputs):
for input in apply.inputs:
if (input not in memo):
if copy_inputs_and_orphans:
cpy = input.clone()
memo[input] = cpy
else:
memo[input] = input
new_apply = apply.clone_with_new_inputs([memo[i] for i in apply.inputs])
memo.setdefault(apply, new_apply)
for (output, new_output) in zip(apply.outputs, new_apply.outputs):
memo.setdefault(output, new_output)
for output in outputs:
if (output not in memo):
memo[output] = output.clone()
return memo
| [
"def",
"clone_get_equiv",
"(",
"inputs",
",",
"outputs",
",",
"copy_inputs_and_orphans",
"=",
"True",
",",
"memo",
"=",
"None",
")",
":",
"if",
"(",
"memo",
"is",
"None",
")",
":",
"memo",
"=",
"{",
"}",
"for",
"input",
"in",
"inputs",
":",
"if",
"co... | return a dictionary that maps from variable and apply nodes in the original graph to a new node in a new graph . | train | false |
3,607 | def config_14(key, salt, string_list):
if ('email' in string_list[18]):
dup = True
elif ('email' in string_list[19]):
dup = False
config_dict = {}
config_dict['Version'] = 'Predator Pain v14'
config_dict['Email Address'] = decrypt_string(key, salt, string_list[4])
config_dict['Email Password'] = decrypt_string(key, salt, string_list[5])
config_dict['SMTP Server'] = decrypt_string(key, salt, string_list[6])
config_dict['SMTP Port'] = string_list[7]
config_dict['Interval Timer'] = string_list[8]
config_dict['FTP Host'] = decrypt_string(key, salt, string_list[12])
config_dict['FTP User'] = decrypt_string(key, salt, string_list[13])
config_dict['FTP Pass'] = decrypt_string(key, salt, string_list[14])
config_dict['PHP Link'] = decrypt_string(key, salt, string_list[15])
if dup:
config_dict['PHP Link'] = decrypt_string(key, salt, string_list[15])
config_dict['Use Email'] = string_list[18]
config_dict['Use FTP'] = string_list[19]
config_dict['Use PHP'] = string_list[20]
config_dict['Download & Exec'] = string_list[25]
if (string_list[24] == 'bindfiles'):
config_dict['Bound Files'] = 'False'
else:
config_dict['Bound Files'] = 'True'
else:
config_dict['Use Email'] = string_list[19]
config_dict['Use FTP'] = string_list[20]
config_dict['Use PHP'] = string_list[21]
config_dict['Download & Exec'] = string_list[26]
if (string_list[25] == 'bindfiles'):
config_dict['Bound Files'] = 'False'
else:
config_dict['Bound Files'] = 'True'
return config_dict
| [
"def",
"config_14",
"(",
"key",
",",
"salt",
",",
"string_list",
")",
":",
"if",
"(",
"'email'",
"in",
"string_list",
"[",
"18",
"]",
")",
":",
"dup",
"=",
"True",
"elif",
"(",
"'email'",
"in",
"string_list",
"[",
"19",
"]",
")",
":",
"dup",
"=",
... | identical strings are not stored multiple times . | train | false |
3,608 | def get_local_size(*args, **kargs):
raise _stub_error
| [
"def",
"get_local_size",
"(",
"*",
"args",
",",
"**",
"kargs",
")",
":",
"raise",
"_stub_error"
] | opencl get_local_size() . | train | false |
3,609 | def external_first_login_authenticate(user, response):
data = (session.data if session._get_current_object() else {})
data.update({'auth_user_external_id_provider': user['external_id_provider'], 'auth_user_external_id': user['external_id'], 'auth_user_fullname': user['fullname'], 'auth_user_access_token': user['access_token'], 'auth_user_external_first_login': True, 'service_url': user['service_url']})
response = create_session(response, data=data)
return response
| [
"def",
"external_first_login_authenticate",
"(",
"user",
",",
"response",
")",
":",
"data",
"=",
"(",
"session",
".",
"data",
"if",
"session",
".",
"_get_current_object",
"(",
")",
"else",
"{",
"}",
")",
"data",
".",
"update",
"(",
"{",
"'auth_user_external_... | create a special unauthenticated session for user login through external identity provider for the first time . | train | false |
3,610 | def test_stacked_line_reverse():
stacked = StackedLine(stack_from_top=True)
stacked.add('one_two', [1, 2])
stacked.add('ten_twelve', [10, 12])
q = stacked.render_pyquery()
assert (set([v.text for v in q('desc.value')]) == set(('11 (+1)', '14 (+2)', '10', '12')))
| [
"def",
"test_stacked_line_reverse",
"(",
")",
":",
"stacked",
"=",
"StackedLine",
"(",
"stack_from_top",
"=",
"True",
")",
"stacked",
".",
"add",
"(",
"'one_two'",
",",
"[",
"1",
",",
"2",
"]",
")",
"stacked",
".",
"add",
"(",
"'ten_twelve'",
",",
"[",
... | test stack from top stacked line . | train | false |
3,612 | def max_return(nbarprice, islong):
high = (-1000000)
low = 1000000
maxdiffs = []
if islong:
for ith_price in nbarprice:
if (ith_price > high):
high = ith_price
low = 1000000
elif (ith_price < low):
low = ith_price
maxdiffs.append((high - low))
return (max(maxdiffs) if maxdiffs else 0)
else:
for ith_price in nbarprice:
if (ith_price < low):
low = ith_price
high = (-1000000)
elif (ith_price > high):
high = ith_price
maxdiffs.append((high - low))
return (max(maxdiffs) if maxdiffs else 0)
| [
"def",
"max_return",
"(",
"nbarprice",
",",
"islong",
")",
":",
"high",
"=",
"(",
"-",
"1000000",
")",
"low",
"=",
"1000000",
"maxdiffs",
"=",
"[",
"]",
"if",
"islong",
":",
"for",
"ith_price",
"in",
"nbarprice",
":",
"if",
"(",
"ith_price",
">",
"hi... | docstring for maxreturn . | train | false |
3,613 | def show_ipsec_site_connection(ipsec_site_connection, profile=None):
conn = _auth(profile)
return conn.show_ipsec_site_connection(ipsec_site_connection)
| [
"def",
"show_ipsec_site_connection",
"(",
"ipsec_site_connection",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_auth",
"(",
"profile",
")",
"return",
"conn",
".",
"show_ipsec_site_connection",
"(",
"ipsec_site_connection",
")"
] | fetches information of a specific ipsecsiteconnection cli example: . | train | false |
3,615 | def get_user_id_for_username(user_name, allow_none=False):
try:
if (c.userobj and (c.userobj.name == user_name)):
return c.userobj.id
except TypeError:
pass
user = model.User.get(user_name)
if user:
return user.id
if allow_none:
return None
raise Exception('Not logged in user')
| [
"def",
"get_user_id_for_username",
"(",
"user_name",
",",
"allow_none",
"=",
"False",
")",
":",
"try",
":",
"if",
"(",
"c",
".",
"userobj",
"and",
"(",
"c",
".",
"userobj",
".",
"name",
"==",
"user_name",
")",
")",
":",
"return",
"c",
".",
"userobj",
... | helper function to get user id . | train | false |
3,616 | def is_parfile(fn):
PAR_ID = 'PAR2\x00PKT'
try:
with open(fn, 'rb') as f:
buf = f.read(8)
return buf.startswith(PAR_ID)
except:
pass
return False
| [
"def",
"is_parfile",
"(",
"fn",
")",
":",
"PAR_ID",
"=",
"'PAR2\\x00PKT'",
"try",
":",
"with",
"open",
"(",
"fn",
",",
"'rb'",
")",
"as",
"f",
":",
"buf",
"=",
"f",
".",
"read",
"(",
"8",
")",
"return",
"buf",
".",
"startswith",
"(",
"PAR_ID",
")... | check quickly whether file has par2 signature . | train | false |
3,617 | def is_conflict_free(path):
rgx = re.compile(u'^(<<<<<<<|\\|\\|\\|\\|\\|\\|\\||>>>>>>>) ')
try:
with core.xopen(path, u'r') as f:
for line in f:
line = core.decode(line, errors=u'ignore')
if rgx.match(line):
if should_stage_conflicts(path):
return True
else:
return False
except IOError:
pass
return True
| [
"def",
"is_conflict_free",
"(",
"path",
")",
":",
"rgx",
"=",
"re",
".",
"compile",
"(",
"u'^(<<<<<<<|\\\\|\\\\|\\\\|\\\\|\\\\|\\\\|\\\\||>>>>>>>) '",
")",
"try",
":",
"with",
"core",
".",
"xopen",
"(",
"path",
",",
"u'r'",
")",
"as",
"f",
":",
"for",
"line"... | return true if path contains no conflict markers . | train | false |
3,618 | @pytest.fixture(scope=u'session')
def celery_parameters():
return {}
| [
"@",
"pytest",
".",
"fixture",
"(",
"scope",
"=",
"u'session'",
")",
"def",
"celery_parameters",
"(",
")",
":",
"return",
"{",
"}"
] | redefine this fixture to change the init parameters of test celery app . | train | false |
3,619 | def make_readonly(path):
mode = os.stat(path).st_mode
os.chmod(path, (mode & (~ stat.S_IWRITE)))
| [
"def",
"make_readonly",
"(",
"path",
")",
":",
"mode",
"=",
"os",
".",
"stat",
"(",
"path",
")",
".",
"st_mode",
"os",
".",
"chmod",
"(",
"path",
",",
"(",
"mode",
"&",
"(",
"~",
"stat",
".",
"S_IWRITE",
")",
")",
")"
] | helper function that is called in the tests to change the access permissions of the given file . | train | false |
3,621 | def dgap_l21(M, G, X, active_set, alpha, n_orient):
GX = np.dot(G[:, active_set], X)
R = (M - GX)
penalty = norm_l21(X, n_orient, copy=True)
nR2 = sum_squared(R)
pobj = ((0.5 * nR2) + (alpha * penalty))
dual_norm = norm_l2inf(np.dot(G.T, R), n_orient, copy=False)
scaling = (alpha / dual_norm)
scaling = min(scaling, 1.0)
dobj = (((0.5 * (scaling ** 2)) * nR2) + (scaling * np.sum((R * GX))))
gap = (pobj - dobj)
return (gap, pobj, dobj, R)
| [
"def",
"dgap_l21",
"(",
"M",
",",
"G",
",",
"X",
",",
"active_set",
",",
"alpha",
",",
"n_orient",
")",
":",
"GX",
"=",
"np",
".",
"dot",
"(",
"G",
"[",
":",
",",
"active_set",
"]",
",",
"X",
")",
"R",
"=",
"(",
"M",
"-",
"GX",
")",
"penalt... | duality gaps for the mixed norm inverse problem . | train | false |
3,622 | def _ll_geom(y, X, beta):
ll = _ll_nbp(y, X, beta, alph=1, Q=0)
return ll
| [
"def",
"_ll_geom",
"(",
"y",
",",
"X",
",",
"beta",
")",
":",
"ll",
"=",
"_ll_nbp",
"(",
"y",
",",
"X",
",",
"beta",
",",
"alph",
"=",
"1",
",",
"Q",
"=",
"0",
")",
"return",
"ll"
] | geometric regression . | train | false |
3,623 | def _combine_rhs(rhs):
series = {}
if isinstance(rhs, Series):
series['x'] = rhs
elif isinstance(rhs, DataFrame):
series = rhs.copy()
elif isinstance(rhs, dict):
for (name, value) in compat.iteritems(rhs):
if isinstance(value, Series):
_safe_update(series, {name: value})
elif isinstance(value, (dict, DataFrame)):
_safe_update(series, value)
else:
raise Exception(('Invalid RHS data type: %s' % type(value)))
else:
raise Exception(('Invalid RHS type: %s' % type(rhs)))
if (not isinstance(series, DataFrame)):
series = DataFrame(series, dtype=float)
return series
| [
"def",
"_combine_rhs",
"(",
"rhs",
")",
":",
"series",
"=",
"{",
"}",
"if",
"isinstance",
"(",
"rhs",
",",
"Series",
")",
":",
"series",
"[",
"'x'",
"]",
"=",
"rhs",
"elif",
"isinstance",
"(",
"rhs",
",",
"DataFrame",
")",
":",
"series",
"=",
"rhs"... | glue input x variables together while checking for potential duplicates . | train | false |
3,624 | def installReactor(shortName):
for installer in getReactorTypes():
if (installer.shortName == shortName):
return installer.install()
raise NoSuchReactor(shortName)
| [
"def",
"installReactor",
"(",
"shortName",
")",
":",
"for",
"installer",
"in",
"getReactorTypes",
"(",
")",
":",
"if",
"(",
"installer",
".",
"shortName",
"==",
"shortName",
")",
":",
"return",
"installer",
".",
"install",
"(",
")",
"raise",
"NoSuchReactor",... | install reactor c{reactor} . | train | false |
3,625 | def cgsnapshot_create(context, values):
return IMPL.cgsnapshot_create(context, values)
| [
"def",
"cgsnapshot_create",
"(",
"context",
",",
"values",
")",
":",
"return",
"IMPL",
".",
"cgsnapshot_create",
"(",
"context",
",",
"values",
")"
] | create a cgsnapshot from the values dictionary . | train | false |
3,626 | def set_form_control_value(control, val):
if isinstance(control, ClientForm.CheckboxControl):
try:
checkbox = control.get()
checkbox.selected = make_boolean(val)
return
except ClientForm.AmbiguityError:
pass
if isinstance(control, ClientForm.ListControl):
if val.startswith('-'):
val = val[1:]
flag = False
else:
flag = True
if val.startswith('+'):
val = val[1:]
try:
item = control.get(name=val)
except ClientForm.ItemNotFoundError:
try:
item = control.get(label=val)
except ClientForm.AmbiguityError:
raise ClientForm.ItemNotFoundError(('multiple matches to value/label "%s" in list control' % (val,)))
except ClientForm.ItemNotFoundError:
raise ClientForm.ItemNotFoundError(('cannot find value/label "%s" in list control' % (val,)))
if flag:
item.selected = 1
else:
item.selected = 0
else:
control.value = val
| [
"def",
"set_form_control_value",
"(",
"control",
",",
"val",
")",
":",
"if",
"isinstance",
"(",
"control",
",",
"ClientForm",
".",
"CheckboxControl",
")",
":",
"try",
":",
"checkbox",
"=",
"control",
".",
"get",
"(",
")",
"checkbox",
".",
"selected",
"=",
... | helper function to deal with setting form values on checkboxes . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.