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 |
|---|---|---|---|---|---|
8,230
|
def check_directory_tree(base_path, file_check, exclusions=set(), pattern='*.py'):
if (not base_path):
return
for (root, dirs, files) in walk(base_path):
check_files(glob(join(root, pattern)), file_check, exclusions)
|
[
"def",
"check_directory_tree",
"(",
"base_path",
",",
"file_check",
",",
"exclusions",
"=",
"set",
"(",
")",
",",
"pattern",
"=",
"'*.py'",
")",
":",
"if",
"(",
"not",
"base_path",
")",
":",
"return",
"for",
"(",
"root",
",",
"dirs",
",",
"files",
")",
"in",
"walk",
"(",
"base_path",
")",
":",
"check_files",
"(",
"glob",
"(",
"join",
"(",
"root",
",",
"pattern",
")",
")",
",",
"file_check",
",",
"exclusions",
")"
] |
checks all files in the directory tree with the file_check function provided .
|
train
| false
|
8,231
|
def _is_unique(url):
return (Service.objects.filter(base_url=url).count() == 0)
|
[
"def",
"_is_unique",
"(",
"url",
")",
":",
"return",
"(",
"Service",
".",
"objects",
".",
"filter",
"(",
"base_url",
"=",
"url",
")",
".",
"count",
"(",
")",
"==",
"0",
")"
] |
determine if a service is already registered based on matching url .
|
train
| false
|
8,232
|
def send_event_publish(email, event_name, link):
message_settings = MessageSettings.query.filter_by(action=NEXT_EVENT).first()
if ((not message_settings) or (message_settings.mail_status == 1)):
send_email(to=email, action=NEXT_EVENT, subject=MAILS[EVENT_PUBLISH]['subject'].format(event_name=event_name), html=MAILS[EVENT_PUBLISH]['message'].format(email=str(email), event_name=str(event_name), link=link))
|
[
"def",
"send_event_publish",
"(",
"email",
",",
"event_name",
",",
"link",
")",
":",
"message_settings",
"=",
"MessageSettings",
".",
"query",
".",
"filter_by",
"(",
"action",
"=",
"NEXT_EVENT",
")",
".",
"first",
"(",
")",
"if",
"(",
"(",
"not",
"message_settings",
")",
"or",
"(",
"message_settings",
".",
"mail_status",
"==",
"1",
")",
")",
":",
"send_email",
"(",
"to",
"=",
"email",
",",
"action",
"=",
"NEXT_EVENT",
",",
"subject",
"=",
"MAILS",
"[",
"EVENT_PUBLISH",
"]",
"[",
"'subject'",
"]",
".",
"format",
"(",
"event_name",
"=",
"event_name",
")",
",",
"html",
"=",
"MAILS",
"[",
"EVENT_PUBLISH",
"]",
"[",
"'message'",
"]",
".",
"format",
"(",
"email",
"=",
"str",
"(",
"email",
")",
",",
"event_name",
"=",
"str",
"(",
"event_name",
")",
",",
"link",
"=",
"link",
")",
")"
] |
send email on publishing event .
|
train
| false
|
8,233
|
def choose_result_int(*inputs):
bitwidth = choose_result_bitwidth(*inputs)
signed = any((tp.signed for tp in inputs))
return types.Integer.from_bitwidth(bitwidth, signed)
|
[
"def",
"choose_result_int",
"(",
"*",
"inputs",
")",
":",
"bitwidth",
"=",
"choose_result_bitwidth",
"(",
"*",
"inputs",
")",
"signed",
"=",
"any",
"(",
"(",
"tp",
".",
"signed",
"for",
"tp",
"in",
"inputs",
")",
")",
"return",
"types",
".",
"Integer",
".",
"from_bitwidth",
"(",
"bitwidth",
",",
"signed",
")"
] |
choose the integer result type for an operation on integer inputs .
|
train
| false
|
8,234
|
def p_expr_group(p):
p[0] = ('GROUP', p[2])
|
[
"def",
"p_expr_group",
"(",
"p",
")",
":",
"p",
"[",
"0",
"]",
"=",
"(",
"'GROUP'",
",",
"p",
"[",
"2",
"]",
")"
] |
expr : lparen expr rparen .
|
train
| false
|
8,237
|
def get_hmm():
return 'hmmm...'
|
[
"def",
"get_hmm",
"(",
")",
":",
"return",
"'hmmm...'"
] |
get a thought .
|
train
| false
|
8,238
|
def org_parents(organisation_id, path=[]):
if (not organisation_id):
return path
db = current.db
s3db = current.s3db
otable = s3db.org_organisation
btable = s3db.org_organisation.with_alias('org_branch_organisation')
ltable = s3db.org_organisation_branch
query = (btable.id == organisation_id)
join = (((((ltable.deleted != True) & (btable.deleted != True)) & (otable.deleted != True)) & (btable.id == ltable.branch_id)) & (otable.id == ltable.organisation_id))
row = db((query & join)).select(otable.id, limitby=(0, 1)).first()
if (row is not None):
organisation_id = row.id
path.insert(0, organisation_id)
return org_parents(organisation_id, path)
else:
return path
|
[
"def",
"org_parents",
"(",
"organisation_id",
",",
"path",
"=",
"[",
"]",
")",
":",
"if",
"(",
"not",
"organisation_id",
")",
":",
"return",
"path",
"db",
"=",
"current",
".",
"db",
"s3db",
"=",
"current",
".",
"s3db",
"otable",
"=",
"s3db",
".",
"org_organisation",
"btable",
"=",
"s3db",
".",
"org_organisation",
".",
"with_alias",
"(",
"'org_branch_organisation'",
")",
"ltable",
"=",
"s3db",
".",
"org_organisation_branch",
"query",
"=",
"(",
"btable",
".",
"id",
"==",
"organisation_id",
")",
"join",
"=",
"(",
"(",
"(",
"(",
"(",
"ltable",
".",
"deleted",
"!=",
"True",
")",
"&",
"(",
"btable",
".",
"deleted",
"!=",
"True",
")",
")",
"&",
"(",
"otable",
".",
"deleted",
"!=",
"True",
")",
")",
"&",
"(",
"btable",
".",
"id",
"==",
"ltable",
".",
"branch_id",
")",
")",
"&",
"(",
"otable",
".",
"id",
"==",
"ltable",
".",
"organisation_id",
")",
")",
"row",
"=",
"db",
"(",
"(",
"query",
"&",
"join",
")",
")",
".",
"select",
"(",
"otable",
".",
"id",
",",
"limitby",
"=",
"(",
"0",
",",
"1",
")",
")",
".",
"first",
"(",
")",
"if",
"(",
"row",
"is",
"not",
"None",
")",
":",
"organisation_id",
"=",
"row",
".",
"id",
"path",
".",
"insert",
"(",
"0",
",",
"organisation_id",
")",
"return",
"org_parents",
"(",
"organisation_id",
",",
"path",
")",
"else",
":",
"return",
"path"
] |
lookup the parent organisations of a branch organisation .
|
train
| false
|
8,239
|
def get_cvxopt_sparse_intf():
import cvxpy.interface.cvxopt_interface.sparse_matrix_interface as smi
return smi.SparseMatrixInterface()
|
[
"def",
"get_cvxopt_sparse_intf",
"(",
")",
":",
"import",
"cvxpy",
".",
"interface",
".",
"cvxopt_interface",
".",
"sparse_matrix_interface",
"as",
"smi",
"return",
"smi",
".",
"SparseMatrixInterface",
"(",
")"
] |
dynamic import of cvxopt sparse interface .
|
train
| false
|
8,240
|
def is_reduced(exp):
return _contains(exp, Reduced)
|
[
"def",
"is_reduced",
"(",
"exp",
")",
":",
"return",
"_contains",
"(",
"exp",
",",
"Reduced",
")"
] |
does exp contain a reduced node .
|
train
| false
|
8,241
|
def _compute_tauk(n, k, maxit=5):
a = ((n % 2) - 0.5)
c = (((((4.0 * floor((n / 2.0))) - (4.0 * k)) + 3.0) * pi) / (((4.0 * floor((n / 2.0))) + (2.0 * a)) + 2.0))
f = (lambda x: ((x - sin(x)) - c))
df = (lambda x: (1.0 - cos(x)))
xi = (0.5 * pi)
for i in range(maxit):
xi = (xi - (f(xi) / df(xi)))
return xi
|
[
"def",
"_compute_tauk",
"(",
"n",
",",
"k",
",",
"maxit",
"=",
"5",
")",
":",
"a",
"=",
"(",
"(",
"n",
"%",
"2",
")",
"-",
"0.5",
")",
"c",
"=",
"(",
"(",
"(",
"(",
"(",
"4.0",
"*",
"floor",
"(",
"(",
"n",
"/",
"2.0",
")",
")",
")",
"-",
"(",
"4.0",
"*",
"k",
")",
")",
"+",
"3.0",
")",
"*",
"pi",
")",
"/",
"(",
"(",
"(",
"4.0",
"*",
"floor",
"(",
"(",
"n",
"/",
"2.0",
")",
")",
")",
"+",
"(",
"2.0",
"*",
"a",
")",
")",
"+",
"2.0",
")",
")",
"f",
"=",
"(",
"lambda",
"x",
":",
"(",
"(",
"x",
"-",
"sin",
"(",
"x",
")",
")",
"-",
"c",
")",
")",
"df",
"=",
"(",
"lambda",
"x",
":",
"(",
"1.0",
"-",
"cos",
"(",
"x",
")",
")",
")",
"xi",
"=",
"(",
"0.5",
"*",
"pi",
")",
"for",
"i",
"in",
"range",
"(",
"maxit",
")",
":",
"xi",
"=",
"(",
"xi",
"-",
"(",
"f",
"(",
"xi",
")",
"/",
"df",
"(",
"xi",
")",
")",
")",
"return",
"xi"
] |
helper function for tricomi initial guesses for details .
|
train
| false
|
8,242
|
def unset_quota_volume(name, path):
cmd = 'volume quota {0}'.format(name)
if path:
cmd += ' remove {0}'.format(path)
if (not _gluster(cmd)):
return False
return True
|
[
"def",
"unset_quota_volume",
"(",
"name",
",",
"path",
")",
":",
"cmd",
"=",
"'volume quota {0}'",
".",
"format",
"(",
"name",
")",
"if",
"path",
":",
"cmd",
"+=",
"' remove {0}'",
".",
"format",
"(",
"path",
")",
"if",
"(",
"not",
"_gluster",
"(",
"cmd",
")",
")",
":",
"return",
"False",
"return",
"True"
] |
unset quota to glusterfs volume .
|
train
| true
|
8,243
|
def test_represent_phasegate():
circuit = (PhaseGate(0) * Qubit('01'))
answer = represent(circuit, nqubits=2)
assert (Matrix([0, I, 0, 0]) == answer)
|
[
"def",
"test_represent_phasegate",
"(",
")",
":",
"circuit",
"=",
"(",
"PhaseGate",
"(",
"0",
")",
"*",
"Qubit",
"(",
"'01'",
")",
")",
"answer",
"=",
"represent",
"(",
"circuit",
",",
"nqubits",
"=",
"2",
")",
"assert",
"(",
"Matrix",
"(",
"[",
"0",
",",
"I",
",",
"0",
",",
"0",
"]",
")",
"==",
"answer",
")"
] |
test the representation of the s gate .
|
train
| false
|
8,244
|
def _get_rvss(minibatch_RVs, local_RVs, observed_RVs, minibatch_tensors, total_size):
if (minibatch_RVs is not None):
_value_error(isinstance(minibatch_RVs, list), 'minibatch_RVs must be a list.')
_value_error(((local_RVs is None) and (observed_RVs is None)), ('When minibatch_RVs is given, local_RVs and ' + 'observed_RVs must be None.'))
s = (floatX(total_size) / minibatch_tensors[0].shape[0])
local_RVs = OrderedDict()
observed_RVs = OrderedDict([(v, s) for v in minibatch_RVs])
else:
_value_error((isinstance(local_RVs, OrderedDict) and isinstance(observed_RVs, OrderedDict)), 'local_RVs and observed_RVs must be OrderedDict.')
return (local_RVs, observed_RVs)
|
[
"def",
"_get_rvss",
"(",
"minibatch_RVs",
",",
"local_RVs",
",",
"observed_RVs",
",",
"minibatch_tensors",
",",
"total_size",
")",
":",
"if",
"(",
"minibatch_RVs",
"is",
"not",
"None",
")",
":",
"_value_error",
"(",
"isinstance",
"(",
"minibatch_RVs",
",",
"list",
")",
",",
"'minibatch_RVs must be a list.'",
")",
"_value_error",
"(",
"(",
"(",
"local_RVs",
"is",
"None",
")",
"and",
"(",
"observed_RVs",
"is",
"None",
")",
")",
",",
"(",
"'When minibatch_RVs is given, local_RVs and '",
"+",
"'observed_RVs must be None.'",
")",
")",
"s",
"=",
"(",
"floatX",
"(",
"total_size",
")",
"/",
"minibatch_tensors",
"[",
"0",
"]",
".",
"shape",
"[",
"0",
"]",
")",
"local_RVs",
"=",
"OrderedDict",
"(",
")",
"observed_RVs",
"=",
"OrderedDict",
"(",
"[",
"(",
"v",
",",
"s",
")",
"for",
"v",
"in",
"minibatch_RVs",
"]",
")",
"else",
":",
"_value_error",
"(",
"(",
"isinstance",
"(",
"local_RVs",
",",
"OrderedDict",
")",
"and",
"isinstance",
"(",
"observed_RVs",
",",
"OrderedDict",
")",
")",
",",
"'local_RVs and observed_RVs must be OrderedDict.'",
")",
"return",
"(",
"local_RVs",
",",
"observed_RVs",
")"
] |
returns local_rvs and observed_rvs .
|
train
| false
|
8,245
|
def unbox_usecase(x):
res = 0
for v in x:
res += v
return res
|
[
"def",
"unbox_usecase",
"(",
"x",
")",
":",
"res",
"=",
"0",
"for",
"v",
"in",
"x",
":",
"res",
"+=",
"v",
"return",
"res"
] |
expect a list of numbers .
|
train
| false
|
8,247
|
def readURLFileLike(urlFileLike):
encoding = urlFileLike.info().get('Content-Encoding')
if (encoding in ('gzip', 'x-gzip', 'deflate')):
content = urlFileLike.read()
if (encoding == 'deflate'):
data = StringIO.StringIO(zlib.decompress(content))
else:
data = gzip.GzipFile('', 'rb', 9, StringIO.StringIO(content))
result = data.read()
else:
result = urlFileLike.read()
urlFileLike.close()
return result
|
[
"def",
"readURLFileLike",
"(",
"urlFileLike",
")",
":",
"encoding",
"=",
"urlFileLike",
".",
"info",
"(",
")",
".",
"get",
"(",
"'Content-Encoding'",
")",
"if",
"(",
"encoding",
"in",
"(",
"'gzip'",
",",
"'x-gzip'",
",",
"'deflate'",
")",
")",
":",
"content",
"=",
"urlFileLike",
".",
"read",
"(",
")",
"if",
"(",
"encoding",
"==",
"'deflate'",
")",
":",
"data",
"=",
"StringIO",
".",
"StringIO",
"(",
"zlib",
".",
"decompress",
"(",
"content",
")",
")",
"else",
":",
"data",
"=",
"gzip",
".",
"GzipFile",
"(",
"''",
",",
"'rb'",
",",
"9",
",",
"StringIO",
".",
"StringIO",
"(",
"content",
")",
")",
"result",
"=",
"data",
".",
"read",
"(",
")",
"else",
":",
"result",
"=",
"urlFileLike",
".",
"read",
"(",
")",
"urlFileLike",
".",
"close",
"(",
")",
"return",
"result"
] |
return the contents of the file like objects as string .
|
train
| false
|
8,248
|
@profiler.trace
def roles_for_user(request, user, project=None, domain=None):
manager = keystoneclient(request, admin=True).roles
if (VERSIONS.active < 3):
return manager.roles_for_user(user, project)
else:
return manager.list(user=user, domain=domain, project=project)
|
[
"@",
"profiler",
".",
"trace",
"def",
"roles_for_user",
"(",
"request",
",",
"user",
",",
"project",
"=",
"None",
",",
"domain",
"=",
"None",
")",
":",
"manager",
"=",
"keystoneclient",
"(",
"request",
",",
"admin",
"=",
"True",
")",
".",
"roles",
"if",
"(",
"VERSIONS",
".",
"active",
"<",
"3",
")",
":",
"return",
"manager",
".",
"roles_for_user",
"(",
"user",
",",
"project",
")",
"else",
":",
"return",
"manager",
".",
"list",
"(",
"user",
"=",
"user",
",",
"domain",
"=",
"domain",
",",
"project",
"=",
"project",
")"
] |
returns a list of user roles scoped to a project or domain .
|
train
| true
|
8,249
|
def get_distance_metres(aLocation1, aLocation2):
dlat = (aLocation2.lat - aLocation1.lat)
dlong = (aLocation2.lon - aLocation1.lon)
return (math.sqrt(((dlat * dlat) + (dlong * dlong))) * 111319.5)
|
[
"def",
"get_distance_metres",
"(",
"aLocation1",
",",
"aLocation2",
")",
":",
"dlat",
"=",
"(",
"aLocation2",
".",
"lat",
"-",
"aLocation1",
".",
"lat",
")",
"dlong",
"=",
"(",
"aLocation2",
".",
"lon",
"-",
"aLocation1",
".",
"lon",
")",
"return",
"(",
"math",
".",
"sqrt",
"(",
"(",
"(",
"dlat",
"*",
"dlat",
")",
"+",
"(",
"dlong",
"*",
"dlong",
")",
")",
")",
"*",
"111319.5",
")"
] |
returns the ground distance in metres between two locationglobal objects .
|
train
| true
|
8,250
|
def list_(channel=None):
pecl_channel_pat = re.compile('^([^ ]+)[ ]+([^ ]+)[ ]+([^ ]+)')
pecls = {}
command = 'list'
if channel:
command = '{0} -c {1}'.format(command, _cmd_quote(channel))
lines = _pecl(command).splitlines()
lines = (l for l in lines if pecl_channel_pat.match(l))
for line in lines:
match = pecl_channel_pat.match(line)
if match:
pecls[match.group(1)] = [match.group(2), match.group(3)]
return pecls
|
[
"def",
"list_",
"(",
"channel",
"=",
"None",
")",
":",
"pecl_channel_pat",
"=",
"re",
".",
"compile",
"(",
"'^([^ ]+)[ ]+([^ ]+)[ ]+([^ ]+)'",
")",
"pecls",
"=",
"{",
"}",
"command",
"=",
"'list'",
"if",
"channel",
":",
"command",
"=",
"'{0} -c {1}'",
".",
"format",
"(",
"command",
",",
"_cmd_quote",
"(",
"channel",
")",
")",
"lines",
"=",
"_pecl",
"(",
"command",
")",
".",
"splitlines",
"(",
")",
"lines",
"=",
"(",
"l",
"for",
"l",
"in",
"lines",
"if",
"pecl_channel_pat",
".",
"match",
"(",
"l",
")",
")",
"for",
"line",
"in",
"lines",
":",
"match",
"=",
"pecl_channel_pat",
".",
"match",
"(",
"line",
")",
"if",
"match",
":",
"pecls",
"[",
"match",
".",
"group",
"(",
"1",
")",
"]",
"=",
"[",
"match",
".",
"group",
"(",
"2",
")",
",",
"match",
".",
"group",
"(",
"3",
")",
"]",
"return",
"pecls"
] |
list installed perl modules .
|
train
| true
|
8,252
|
def serial_listen_addr(migrate_data):
listen_addr = None
if migrate_data.obj_attr_is_set('serial_listen_addr'):
listen_addr = migrate_data.serial_listen_addr
return listen_addr
|
[
"def",
"serial_listen_addr",
"(",
"migrate_data",
")",
":",
"listen_addr",
"=",
"None",
"if",
"migrate_data",
".",
"obj_attr_is_set",
"(",
"'serial_listen_addr'",
")",
":",
"listen_addr",
"=",
"migrate_data",
".",
"serial_listen_addr",
"return",
"listen_addr"
] |
returns listen address serial from a libvirtlivemigratedata .
|
train
| false
|
8,253
|
def sync_queues(saltenv='base'):
return salt.utils.extmods.sync(__opts__, 'queues', saltenv=saltenv)[0]
|
[
"def",
"sync_queues",
"(",
"saltenv",
"=",
"'base'",
")",
":",
"return",
"salt",
".",
"utils",
".",
"extmods",
".",
"sync",
"(",
"__opts__",
",",
"'queues'",
",",
"saltenv",
"=",
"saltenv",
")",
"[",
"0",
"]"
] |
sync queue modules from salt://_queues to the master saltenv : base the fileserver environment from which to sync .
|
train
| false
|
8,255
|
def test_date_labels():
datey = DateLine(truncate_label=1000)
datey.add('dates', [(date(2013, 1, 2), 300), (date(2013, 1, 12), 412), (date(2013, 2, 2), 823), (date(2013, 2, 22), 672)])
datey.x_labels = [date(2013, 1, 1), date(2013, 2, 1), date(2013, 3, 1)]
q = datey.render_pyquery()
assert (list(map((lambda t: t.split(' ')[0]), q('.axis.x text').map(texts))) == ['2013-01-01', '2013-02-01', '2013-03-01'])
|
[
"def",
"test_date_labels",
"(",
")",
":",
"datey",
"=",
"DateLine",
"(",
"truncate_label",
"=",
"1000",
")",
"datey",
".",
"add",
"(",
"'dates'",
",",
"[",
"(",
"date",
"(",
"2013",
",",
"1",
",",
"2",
")",
",",
"300",
")",
",",
"(",
"date",
"(",
"2013",
",",
"1",
",",
"12",
")",
",",
"412",
")",
",",
"(",
"date",
"(",
"2013",
",",
"2",
",",
"2",
")",
",",
"823",
")",
",",
"(",
"date",
"(",
"2013",
",",
"2",
",",
"22",
")",
",",
"672",
")",
"]",
")",
"datey",
".",
"x_labels",
"=",
"[",
"date",
"(",
"2013",
",",
"1",
",",
"1",
")",
",",
"date",
"(",
"2013",
",",
"2",
",",
"1",
")",
",",
"date",
"(",
"2013",
",",
"3",
",",
"1",
")",
"]",
"q",
"=",
"datey",
".",
"render_pyquery",
"(",
")",
"assert",
"(",
"list",
"(",
"map",
"(",
"(",
"lambda",
"t",
":",
"t",
".",
"split",
"(",
"' '",
")",
"[",
"0",
"]",
")",
",",
"q",
"(",
"'.axis.x text'",
")",
".",
"map",
"(",
"texts",
")",
")",
")",
"==",
"[",
"'2013-01-01'",
",",
"'2013-02-01'",
",",
"'2013-03-01'",
"]",
")"
] |
test dateline with xrange .
|
train
| false
|
8,256
|
def build_recursive_traversal_spec(client_factory):
visit_folders_select_spec = build_selection_spec(client_factory, 'visitFolders')
dc_to_hf = build_traversal_spec(client_factory, 'dc_to_hf', 'Datacenter', 'hostFolder', False, [visit_folders_select_spec])
dc_to_vmf = build_traversal_spec(client_factory, 'dc_to_vmf', 'Datacenter', 'vmFolder', False, [visit_folders_select_spec])
h_to_vm = build_traversal_spec(client_factory, 'h_to_vm', 'HostSystem', 'vm', False, [visit_folders_select_spec])
cr_to_h = build_traversal_spec(client_factory, 'cr_to_h', 'ComputeResource', 'host', False, [])
cr_to_ds = build_traversal_spec(client_factory, 'cr_to_ds', 'ComputeResource', 'datastore', False, [])
rp_to_rp_select_spec = build_selection_spec(client_factory, 'rp_to_rp')
rp_to_vm_select_spec = build_selection_spec(client_factory, 'rp_to_vm')
cr_to_rp = build_traversal_spec(client_factory, 'cr_to_rp', 'ComputeResource', 'resourcePool', False, [rp_to_rp_select_spec, rp_to_vm_select_spec])
rp_to_rp = build_traversal_spec(client_factory, 'rp_to_rp', 'ResourcePool', 'resourcePool', False, [rp_to_rp_select_spec, rp_to_vm_select_spec])
rp_to_vm = build_traversal_spec(client_factory, 'rp_to_vm', 'ResourcePool', 'vm', False, [rp_to_rp_select_spec, rp_to_vm_select_spec])
traversal_spec = build_traversal_spec(client_factory, 'visitFolders', 'Folder', 'childEntity', False, [visit_folders_select_spec, dc_to_hf, dc_to_vmf, cr_to_ds, cr_to_h, cr_to_rp, rp_to_rp, h_to_vm, rp_to_vm])
return traversal_spec
|
[
"def",
"build_recursive_traversal_spec",
"(",
"client_factory",
")",
":",
"visit_folders_select_spec",
"=",
"build_selection_spec",
"(",
"client_factory",
",",
"'visitFolders'",
")",
"dc_to_hf",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'dc_to_hf'",
",",
"'Datacenter'",
",",
"'hostFolder'",
",",
"False",
",",
"[",
"visit_folders_select_spec",
"]",
")",
"dc_to_vmf",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'dc_to_vmf'",
",",
"'Datacenter'",
",",
"'vmFolder'",
",",
"False",
",",
"[",
"visit_folders_select_spec",
"]",
")",
"h_to_vm",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'h_to_vm'",
",",
"'HostSystem'",
",",
"'vm'",
",",
"False",
",",
"[",
"visit_folders_select_spec",
"]",
")",
"cr_to_h",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'cr_to_h'",
",",
"'ComputeResource'",
",",
"'host'",
",",
"False",
",",
"[",
"]",
")",
"cr_to_ds",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'cr_to_ds'",
",",
"'ComputeResource'",
",",
"'datastore'",
",",
"False",
",",
"[",
"]",
")",
"rp_to_rp_select_spec",
"=",
"build_selection_spec",
"(",
"client_factory",
",",
"'rp_to_rp'",
")",
"rp_to_vm_select_spec",
"=",
"build_selection_spec",
"(",
"client_factory",
",",
"'rp_to_vm'",
")",
"cr_to_rp",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'cr_to_rp'",
",",
"'ComputeResource'",
",",
"'resourcePool'",
",",
"False",
",",
"[",
"rp_to_rp_select_spec",
",",
"rp_to_vm_select_spec",
"]",
")",
"rp_to_rp",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'rp_to_rp'",
",",
"'ResourcePool'",
",",
"'resourcePool'",
",",
"False",
",",
"[",
"rp_to_rp_select_spec",
",",
"rp_to_vm_select_spec",
"]",
")",
"rp_to_vm",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'rp_to_vm'",
",",
"'ResourcePool'",
",",
"'vm'",
",",
"False",
",",
"[",
"rp_to_rp_select_spec",
",",
"rp_to_vm_select_spec",
"]",
")",
"traversal_spec",
"=",
"build_traversal_spec",
"(",
"client_factory",
",",
"'visitFolders'",
",",
"'Folder'",
",",
"'childEntity'",
",",
"False",
",",
"[",
"visit_folders_select_spec",
",",
"dc_to_hf",
",",
"dc_to_vmf",
",",
"cr_to_ds",
",",
"cr_to_h",
",",
"cr_to_rp",
",",
"rp_to_rp",
",",
"h_to_vm",
",",
"rp_to_vm",
"]",
")",
"return",
"traversal_spec"
] |
builds the recursive traversal spec to traverse the object managed object hierarchy .
|
train
| false
|
8,257
|
@world.absorb
def css_find(css, wait_time=GLOBAL_WAIT_FOR_TIMEOUT):
wait_for_present(css_selector=css, timeout=wait_time)
return world.browser.find_by_css(css)
|
[
"@",
"world",
".",
"absorb",
"def",
"css_find",
"(",
"css",
",",
"wait_time",
"=",
"GLOBAL_WAIT_FOR_TIMEOUT",
")",
":",
"wait_for_present",
"(",
"css_selector",
"=",
"css",
",",
"timeout",
"=",
"wait_time",
")",
"return",
"world",
".",
"browser",
".",
"find_by_css",
"(",
"css",
")"
] |
wait for the element(s) as defined by css locator to be present .
|
train
| false
|
8,259
|
def getCounter(technique):
return kb.counters.get(technique, 0)
|
[
"def",
"getCounter",
"(",
"technique",
")",
":",
"return",
"kb",
".",
"counters",
".",
"get",
"(",
"technique",
",",
"0",
")"
] |
returns query counter for a given technique .
|
train
| false
|
8,261
|
def sample_user_agent():
class DummyConfig(object, ):
'Shim for computing a sample user agent.'
def __init__(self):
self.authenticator = 'XXX'
self.installer = 'YYY'
self.user_agent = None
return determine_user_agent(DummyConfig())
|
[
"def",
"sample_user_agent",
"(",
")",
":",
"class",
"DummyConfig",
"(",
"object",
",",
")",
":",
"def",
"__init__",
"(",
"self",
")",
":",
"self",
".",
"authenticator",
"=",
"'XXX'",
"self",
".",
"installer",
"=",
"'YYY'",
"self",
".",
"user_agent",
"=",
"None",
"return",
"determine_user_agent",
"(",
"DummyConfig",
"(",
")",
")"
] |
document what this certbots user agent string will be like .
|
train
| false
|
8,262
|
def reserve_hosts(host_filter_data, username=None):
hosts = models.Host.query_objects(host_filter_data)
reservations.create(hosts_to_reserve=[h.hostname for h in hosts], username=username)
|
[
"def",
"reserve_hosts",
"(",
"host_filter_data",
",",
"username",
"=",
"None",
")",
":",
"hosts",
"=",
"models",
".",
"Host",
".",
"query_objects",
"(",
"host_filter_data",
")",
"reservations",
".",
"create",
"(",
"hosts_to_reserve",
"=",
"[",
"h",
".",
"hostname",
"for",
"h",
"in",
"hosts",
"]",
",",
"username",
"=",
"username",
")"
] |
reserve some hosts .
|
train
| false
|
8,264
|
def pointer_add(builder, ptr, offset, return_type=None):
intptr = builder.ptrtoint(ptr, intp_t)
if isinstance(offset, utils.INT_TYPES):
offset = intp_t(offset)
intptr = builder.add(intptr, offset)
return builder.inttoptr(intptr, (return_type or ptr.type))
|
[
"def",
"pointer_add",
"(",
"builder",
",",
"ptr",
",",
"offset",
",",
"return_type",
"=",
"None",
")",
":",
"intptr",
"=",
"builder",
".",
"ptrtoint",
"(",
"ptr",
",",
"intp_t",
")",
"if",
"isinstance",
"(",
"offset",
",",
"utils",
".",
"INT_TYPES",
")",
":",
"offset",
"=",
"intp_t",
"(",
"offset",
")",
"intptr",
"=",
"builder",
".",
"add",
"(",
"intptr",
",",
"offset",
")",
"return",
"builder",
".",
"inttoptr",
"(",
"intptr",
",",
"(",
"return_type",
"or",
"ptr",
".",
"type",
")",
")"
] |
add an integral *offset* to pointer *ptr* .
|
train
| false
|
8,265
|
def test_vm_gc():
x = theano.tensor.vector()
p = RunOnce()(x)
mode = theano.Mode(linker=theano.gof.vm.VM_Linker(lazy=True))
f = theano.function([theano.In(x, mutable=True)], [(p + 1), (p + 2)], mode=mode)
f([1, 2, 3])
p = RunOnce()(x)
pp = (p + p)
f = theano.function([x], [(pp + pp)], mode=mode)
f([1, 2, 3])
|
[
"def",
"test_vm_gc",
"(",
")",
":",
"x",
"=",
"theano",
".",
"tensor",
".",
"vector",
"(",
")",
"p",
"=",
"RunOnce",
"(",
")",
"(",
"x",
")",
"mode",
"=",
"theano",
".",
"Mode",
"(",
"linker",
"=",
"theano",
".",
"gof",
".",
"vm",
".",
"VM_Linker",
"(",
"lazy",
"=",
"True",
")",
")",
"f",
"=",
"theano",
".",
"function",
"(",
"[",
"theano",
".",
"In",
"(",
"x",
",",
"mutable",
"=",
"True",
")",
"]",
",",
"[",
"(",
"p",
"+",
"1",
")",
",",
"(",
"p",
"+",
"2",
")",
"]",
",",
"mode",
"=",
"mode",
")",
"f",
"(",
"[",
"1",
",",
"2",
",",
"3",
"]",
")",
"p",
"=",
"RunOnce",
"(",
")",
"(",
"x",
")",
"pp",
"=",
"(",
"p",
"+",
"p",
")",
"f",
"=",
"theano",
".",
"function",
"(",
"[",
"x",
"]",
",",
"[",
"(",
"pp",
"+",
"pp",
")",
"]",
",",
"mode",
"=",
"mode",
")",
"f",
"(",
"[",
"1",
",",
"2",
",",
"3",
"]",
")"
] |
this already caused a bug in the trunk of theano .
|
train
| false
|
8,266
|
def _bootstrap_debian(name, **kwargs):
version = kwargs.get('version', False)
if (not version):
if (__grains__['os'].lower() == 'debian'):
version = __grains__['osrelease']
else:
version = 'stable'
release_blacklist = ['hamm', 'slink', 'potato', 'woody', 'sarge', 'etch', 'lenny', 'squeeze', 'wheezy']
if (version in release_blacklist):
raise CommandExecutionError('Unsupported Debian version "{0}". Only "stable" or "jessie" and newer are supported'.format(version))
dst = _make_container_root(name)
cmd = 'debootstrap --arch=amd64 {0} {1}'.format(version, dst)
ret = __salt__['cmd.run_all'](cmd, python_shell=False)
if (ret['retcode'] != 0):
_build_failed(dst, name)
return ret
|
[
"def",
"_bootstrap_debian",
"(",
"name",
",",
"**",
"kwargs",
")",
":",
"version",
"=",
"kwargs",
".",
"get",
"(",
"'version'",
",",
"False",
")",
"if",
"(",
"not",
"version",
")",
":",
"if",
"(",
"__grains__",
"[",
"'os'",
"]",
".",
"lower",
"(",
")",
"==",
"'debian'",
")",
":",
"version",
"=",
"__grains__",
"[",
"'osrelease'",
"]",
"else",
":",
"version",
"=",
"'stable'",
"release_blacklist",
"=",
"[",
"'hamm'",
",",
"'slink'",
",",
"'potato'",
",",
"'woody'",
",",
"'sarge'",
",",
"'etch'",
",",
"'lenny'",
",",
"'squeeze'",
",",
"'wheezy'",
"]",
"if",
"(",
"version",
"in",
"release_blacklist",
")",
":",
"raise",
"CommandExecutionError",
"(",
"'Unsupported Debian version \"{0}\". Only \"stable\" or \"jessie\" and newer are supported'",
".",
"format",
"(",
"version",
")",
")",
"dst",
"=",
"_make_container_root",
"(",
"name",
")",
"cmd",
"=",
"'debootstrap --arch=amd64 {0} {1}'",
".",
"format",
"(",
"version",
",",
"dst",
")",
"ret",
"=",
"__salt__",
"[",
"'cmd.run_all'",
"]",
"(",
"cmd",
",",
"python_shell",
"=",
"False",
")",
"if",
"(",
"ret",
"[",
"'retcode'",
"]",
"!=",
"0",
")",
":",
"_build_failed",
"(",
"dst",
",",
"name",
")",
"return",
"ret"
] |
bootstrap a debian linux container .
|
train
| true
|
8,268
|
def changeRememberedMaster(newPassword):
global MasterPassword
if (newPassword == u''):
MasterPassword = None
else:
MasterPassword = pwEncode(newPassword)
|
[
"def",
"changeRememberedMaster",
"(",
"newPassword",
")",
":",
"global",
"MasterPassword",
"if",
"(",
"newPassword",
"==",
"u''",
")",
":",
"MasterPassword",
"=",
"None",
"else",
":",
"MasterPassword",
"=",
"pwEncode",
"(",
"newPassword",
")"
] |
module function to change the remembered master password .
|
train
| false
|
8,269
|
def seq_concat_seq(a, b):
prefer = type(max([a, b], key=len))
if (not isinstance(a, prefer)):
a = prefer(a)
if (not isinstance(b, prefer)):
b = prefer(b)
return (a + b)
|
[
"def",
"seq_concat_seq",
"(",
"a",
",",
"b",
")",
":",
"prefer",
"=",
"type",
"(",
"max",
"(",
"[",
"a",
",",
"b",
"]",
",",
"key",
"=",
"len",
")",
")",
"if",
"(",
"not",
"isinstance",
"(",
"a",
",",
"prefer",
")",
")",
":",
"a",
"=",
"prefer",
"(",
"a",
")",
"if",
"(",
"not",
"isinstance",
"(",
"b",
",",
"prefer",
")",
")",
":",
"b",
"=",
"prefer",
"(",
"b",
")",
"return",
"(",
"a",
"+",
"b",
")"
] |
concatenate two sequences: a + b .
|
train
| false
|
8,270
|
def _gcd_interpolate(h, x, ring):
(f, i) = (ring.zero, 0)
if (ring.ngens == 1):
while h:
g = (h % x)
if (g > (x // 2)):
g -= x
h = ((h - g) // x)
if g:
f[(i,)] = g
i += 1
else:
while h:
g = h.trunc_ground(x)
h = (h - g).quo_ground(x)
if g:
for (monom, coeff) in g.iterterms():
f[((i,) + monom)] = coeff
i += 1
if (f.LC < 0):
return (- f)
else:
return f
|
[
"def",
"_gcd_interpolate",
"(",
"h",
",",
"x",
",",
"ring",
")",
":",
"(",
"f",
",",
"i",
")",
"=",
"(",
"ring",
".",
"zero",
",",
"0",
")",
"if",
"(",
"ring",
".",
"ngens",
"==",
"1",
")",
":",
"while",
"h",
":",
"g",
"=",
"(",
"h",
"%",
"x",
")",
"if",
"(",
"g",
">",
"(",
"x",
"//",
"2",
")",
")",
":",
"g",
"-=",
"x",
"h",
"=",
"(",
"(",
"h",
"-",
"g",
")",
"//",
"x",
")",
"if",
"g",
":",
"f",
"[",
"(",
"i",
",",
")",
"]",
"=",
"g",
"i",
"+=",
"1",
"else",
":",
"while",
"h",
":",
"g",
"=",
"h",
".",
"trunc_ground",
"(",
"x",
")",
"h",
"=",
"(",
"h",
"-",
"g",
")",
".",
"quo_ground",
"(",
"x",
")",
"if",
"g",
":",
"for",
"(",
"monom",
",",
"coeff",
")",
"in",
"g",
".",
"iterterms",
"(",
")",
":",
"f",
"[",
"(",
"(",
"i",
",",
")",
"+",
"monom",
")",
"]",
"=",
"coeff",
"i",
"+=",
"1",
"if",
"(",
"f",
".",
"LC",
"<",
"0",
")",
":",
"return",
"(",
"-",
"f",
")",
"else",
":",
"return",
"f"
] |
interpolate polynomial gcd from integer gcd .
|
train
| false
|
8,271
|
def WriteXmlIfChanged(content, path, encoding='utf-8', pretty=False, win32=False):
xml_string = XmlToString(content, encoding, pretty)
if (win32 and (os.linesep != '\r\n')):
xml_string = xml_string.replace('\n', '\r\n')
try:
xml_string = xml_string.encode(encoding)
except Exception:
xml_string = unicode(xml_string, 'latin-1').encode(encoding)
try:
f = open(path, 'r')
existing = f.read()
f.close()
except:
existing = None
if (existing != xml_string):
f = open(path, 'w')
f.write(xml_string)
f.close()
|
[
"def",
"WriteXmlIfChanged",
"(",
"content",
",",
"path",
",",
"encoding",
"=",
"'utf-8'",
",",
"pretty",
"=",
"False",
",",
"win32",
"=",
"False",
")",
":",
"xml_string",
"=",
"XmlToString",
"(",
"content",
",",
"encoding",
",",
"pretty",
")",
"if",
"(",
"win32",
"and",
"(",
"os",
".",
"linesep",
"!=",
"'\\r\\n'",
")",
")",
":",
"xml_string",
"=",
"xml_string",
".",
"replace",
"(",
"'\\n'",
",",
"'\\r\\n'",
")",
"try",
":",
"xml_string",
"=",
"xml_string",
".",
"encode",
"(",
"encoding",
")",
"except",
"Exception",
":",
"xml_string",
"=",
"unicode",
"(",
"xml_string",
",",
"'latin-1'",
")",
".",
"encode",
"(",
"encoding",
")",
"try",
":",
"f",
"=",
"open",
"(",
"path",
",",
"'r'",
")",
"existing",
"=",
"f",
".",
"read",
"(",
")",
"f",
".",
"close",
"(",
")",
"except",
":",
"existing",
"=",
"None",
"if",
"(",
"existing",
"!=",
"xml_string",
")",
":",
"f",
"=",
"open",
"(",
"path",
",",
"'w'",
")",
"f",
".",
"write",
"(",
"xml_string",
")",
"f",
".",
"close",
"(",
")"
] |
writes the xml content to disk .
|
train
| false
|
8,272
|
def _noop(object):
return object
|
[
"def",
"_noop",
"(",
"object",
")",
":",
"return",
"object"
] |
return the passed object unmodified .
|
train
| false
|
8,273
|
def seguid(seq):
import hashlib
import base64
m = hashlib.sha1()
try:
seq = str(seq)
except AttributeError:
pass
m.update(_as_bytes(seq.upper()))
try:
return base64.encodebytes(m.digest()).decode().replace('\n', '').rstrip('=')
except AttributeError:
pass
return base64.b64encode(m.digest()).rstrip('=')
|
[
"def",
"seguid",
"(",
"seq",
")",
":",
"import",
"hashlib",
"import",
"base64",
"m",
"=",
"hashlib",
".",
"sha1",
"(",
")",
"try",
":",
"seq",
"=",
"str",
"(",
"seq",
")",
"except",
"AttributeError",
":",
"pass",
"m",
".",
"update",
"(",
"_as_bytes",
"(",
"seq",
".",
"upper",
"(",
")",
")",
")",
"try",
":",
"return",
"base64",
".",
"encodebytes",
"(",
"m",
".",
"digest",
"(",
")",
")",
".",
"decode",
"(",
")",
".",
"replace",
"(",
"'\\n'",
",",
"''",
")",
".",
"rstrip",
"(",
"'='",
")",
"except",
"AttributeError",
":",
"pass",
"return",
"base64",
".",
"b64encode",
"(",
"m",
".",
"digest",
"(",
")",
")",
".",
"rstrip",
"(",
"'='",
")"
] |
returns the seguid for a sequence .
|
train
| false
|
8,274
|
def split_on_newlines(s):
res = []
for x in s.split('\r\n'):
for y in x.split('\r'):
res.extend(y.split('\n'))
return res
|
[
"def",
"split_on_newlines",
"(",
"s",
")",
":",
"res",
"=",
"[",
"]",
"for",
"x",
"in",
"s",
".",
"split",
"(",
"'\\r\\n'",
")",
":",
"for",
"y",
"in",
"x",
".",
"split",
"(",
"'\\r'",
")",
":",
"res",
".",
"extend",
"(",
"y",
".",
"split",
"(",
"'\\n'",
")",
")",
"return",
"res"
] |
splits s on all of the three newline sequences: " " .
|
train
| false
|
8,276
|
def duplicate(image):
return image.copy()
|
[
"def",
"duplicate",
"(",
"image",
")",
":",
"return",
"image",
".",
"copy",
"(",
")"
] |
copy a channel .
|
train
| false
|
8,277
|
def set_log_methods(cls, logger):
cls.__logger = logger
for attr in ('debug', 'info', 'warning', 'error', 'critical', 'exception'):
setattr(cls, attr, getattr(logger, attr))
|
[
"def",
"set_log_methods",
"(",
"cls",
",",
"logger",
")",
":",
"cls",
".",
"__logger",
"=",
"logger",
"for",
"attr",
"in",
"(",
"'debug'",
",",
"'info'",
",",
"'warning'",
",",
"'error'",
",",
"'critical'",
",",
"'exception'",
")",
":",
"setattr",
"(",
"cls",
",",
"attr",
",",
"getattr",
"(",
"logger",
",",
"attr",
")",
")"
] |
bind standard loggers methods as methods on the class .
|
train
| false
|
8,278
|
@handle_response_format
@treeio_login_required
def ticket_delete(request, ticket_id, response_format='html'):
ticket = get_object_or_404(Ticket, pk=ticket_id)
if (not request.user.profile.has_permission(ticket, mode='w')):
return user_denied(request, message="You don't have access to this Ticket")
if request.POST:
if ('delete' in request.POST):
if ('trash' in request.POST):
ticket.trash = True
ticket.save()
else:
ticket.delete()
return HttpResponseRedirect(reverse('services_index'))
elif ('cancel' in request.POST):
return HttpResponseRedirect(reverse('services_ticket_view', args=[ticket.id]))
context = _get_default_context(request)
context.update({'ticket': ticket})
return render_to_response('services/ticket_delete', context, context_instance=RequestContext(request), response_format=response_format)
|
[
"@",
"handle_response_format",
"@",
"treeio_login_required",
"def",
"ticket_delete",
"(",
"request",
",",
"ticket_id",
",",
"response_format",
"=",
"'html'",
")",
":",
"ticket",
"=",
"get_object_or_404",
"(",
"Ticket",
",",
"pk",
"=",
"ticket_id",
")",
"if",
"(",
"not",
"request",
".",
"user",
".",
"profile",
".",
"has_permission",
"(",
"ticket",
",",
"mode",
"=",
"'w'",
")",
")",
":",
"return",
"user_denied",
"(",
"request",
",",
"message",
"=",
"\"You don't have access to this Ticket\"",
")",
"if",
"request",
".",
"POST",
":",
"if",
"(",
"'delete'",
"in",
"request",
".",
"POST",
")",
":",
"if",
"(",
"'trash'",
"in",
"request",
".",
"POST",
")",
":",
"ticket",
".",
"trash",
"=",
"True",
"ticket",
".",
"save",
"(",
")",
"else",
":",
"ticket",
".",
"delete",
"(",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'services_index'",
")",
")",
"elif",
"(",
"'cancel'",
"in",
"request",
".",
"POST",
")",
":",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'services_ticket_view'",
",",
"args",
"=",
"[",
"ticket",
".",
"id",
"]",
")",
")",
"context",
"=",
"_get_default_context",
"(",
"request",
")",
"context",
".",
"update",
"(",
"{",
"'ticket'",
":",
"ticket",
"}",
")",
"return",
"render_to_response",
"(",
"'services/ticket_delete'",
",",
"context",
",",
"context_instance",
"=",
"RequestContext",
"(",
"request",
")",
",",
"response_format",
"=",
"response_format",
")"
] |
ticket delete .
|
train
| false
|
8,279
|
def analyze_module(pycore, pymodule, should_analyze, search_subscopes, followed_calls):
_analyze_node(pycore, pymodule, should_analyze, search_subscopes, followed_calls)
|
[
"def",
"analyze_module",
"(",
"pycore",
",",
"pymodule",
",",
"should_analyze",
",",
"search_subscopes",
",",
"followed_calls",
")",
":",
"_analyze_node",
"(",
"pycore",
",",
"pymodule",
",",
"should_analyze",
",",
"search_subscopes",
",",
"followed_calls",
")"
] |
perform static object analysis on a python file in the project note that this might be really time consuming .
|
train
| true
|
8,280
|
def autosummary_toc_visit_latex(self, node):
pass
|
[
"def",
"autosummary_toc_visit_latex",
"(",
"self",
",",
"node",
")",
":",
"pass"
] |
show autosummary toctree in latex .
|
train
| false
|
8,281
|
def resource_query(name):
def make_responder(query_func):
def responder(queries):
return app.response_class(json_generator(query_func(queries), root='results', expand=is_expand()), mimetype='application/json')
responder.__name__ = 'query_{0}'.format(name)
return responder
return make_responder
|
[
"def",
"resource_query",
"(",
"name",
")",
":",
"def",
"make_responder",
"(",
"query_func",
")",
":",
"def",
"responder",
"(",
"queries",
")",
":",
"return",
"app",
".",
"response_class",
"(",
"json_generator",
"(",
"query_func",
"(",
"queries",
")",
",",
"root",
"=",
"'results'",
",",
"expand",
"=",
"is_expand",
"(",
")",
")",
",",
"mimetype",
"=",
"'application/json'",
")",
"responder",
".",
"__name__",
"=",
"'query_{0}'",
".",
"format",
"(",
"name",
")",
"return",
"responder",
"return",
"make_responder"
] |
decorates a function to handle restful http queries for resources .
|
train
| false
|
8,282
|
def _parse_mongodb_databases_kv(line, out, prefix=None, force_type=None, value_name=None):
try:
(key, value) = line.split(' =', 1)
value = value[1:]
except ValueError:
sys.stderr.write(('WARNING: unknown keyword %r\r\n' % line))
return
if (key == '$err'):
key = 'errmsg'
if (prefix is not None):
key = ('%s_%s' % (prefix, key))
if (force_type is not None):
value = force_type(value)
else:
value = _MONGODB_DATABASES_TYPES.get(key, (lambda x: x))(value)
if isinstance(out, dict):
assert (key not in out)
out[key] = value
elif isinstance(out, list):
out.append({'name': key, value_name: value})
|
[
"def",
"_parse_mongodb_databases_kv",
"(",
"line",
",",
"out",
",",
"prefix",
"=",
"None",
",",
"force_type",
"=",
"None",
",",
"value_name",
"=",
"None",
")",
":",
"try",
":",
"(",
"key",
",",
"value",
")",
"=",
"line",
".",
"split",
"(",
"' ='",
",",
"1",
")",
"value",
"=",
"value",
"[",
"1",
":",
"]",
"except",
"ValueError",
":",
"sys",
".",
"stderr",
".",
"write",
"(",
"(",
"'WARNING: unknown keyword %r\\r\\n'",
"%",
"line",
")",
")",
"return",
"if",
"(",
"key",
"==",
"'$err'",
")",
":",
"key",
"=",
"'errmsg'",
"if",
"(",
"prefix",
"is",
"not",
"None",
")",
":",
"key",
"=",
"(",
"'%s_%s'",
"%",
"(",
"prefix",
",",
"key",
")",
")",
"if",
"(",
"force_type",
"is",
"not",
"None",
")",
":",
"value",
"=",
"force_type",
"(",
"value",
")",
"else",
":",
"value",
"=",
"_MONGODB_DATABASES_TYPES",
".",
"get",
"(",
"key",
",",
"(",
"lambda",
"x",
":",
"x",
")",
")",
"(",
"value",
")",
"if",
"isinstance",
"(",
"out",
",",
"dict",
")",
":",
"assert",
"(",
"key",
"not",
"in",
"out",
")",
"out",
"[",
"key",
"]",
"=",
"value",
"elif",
"isinstance",
"(",
"out",
",",
"list",
")",
":",
"out",
".",
"append",
"(",
"{",
"'name'",
":",
"key",
",",
"value_name",
":",
"value",
"}",
")"
] |
parse key = value lines from mongodb-databases output .
|
train
| false
|
8,283
|
@register.function
@jinja2.contextfunction
def collection_widgets(context, collection, condensed=False):
c = dict(context.items())
if collection:
c.update({'condensed': condensed, 'c': collection})
template = get_env().get_template('bandwagon/collection_widgets.html')
return jinja2.Markup(template.render(c))
|
[
"@",
"register",
".",
"function",
"@",
"jinja2",
".",
"contextfunction",
"def",
"collection_widgets",
"(",
"context",
",",
"collection",
",",
"condensed",
"=",
"False",
")",
":",
"c",
"=",
"dict",
"(",
"context",
".",
"items",
"(",
")",
")",
"if",
"collection",
":",
"c",
".",
"update",
"(",
"{",
"'condensed'",
":",
"condensed",
",",
"'c'",
":",
"collection",
"}",
")",
"template",
"=",
"get_env",
"(",
")",
".",
"get_template",
"(",
"'bandwagon/collection_widgets.html'",
")",
"return",
"jinja2",
".",
"Markup",
"(",
"template",
".",
"render",
"(",
"c",
")",
")"
] |
displays collection widgets .
|
train
| false
|
8,284
|
def _interpret_emr_step_stderr(fs, matches):
for match in matches:
path = match['path']
error = _parse_task_stderr(_cat_log(fs, path))
if error:
error['path'] = path
return dict(errors=[dict(task_error=error)])
return {}
|
[
"def",
"_interpret_emr_step_stderr",
"(",
"fs",
",",
"matches",
")",
":",
"for",
"match",
"in",
"matches",
":",
"path",
"=",
"match",
"[",
"'path'",
"]",
"error",
"=",
"_parse_task_stderr",
"(",
"_cat_log",
"(",
"fs",
",",
"path",
")",
")",
"if",
"error",
":",
"error",
"[",
"'path'",
"]",
"=",
"path",
"return",
"dict",
"(",
"errors",
"=",
"[",
"dict",
"(",
"task_error",
"=",
"error",
")",
"]",
")",
"return",
"{",
"}"
] |
extract information from step stderr (see :py:func:~mrjob .
|
train
| false
|
8,285
|
def _complete_path(path=None):
if (not path):
return _listdir('.')
(dirname, rest) = os.path.split(path)
tmp = (dirname if dirname else '.')
res = [p for p in _listdir(tmp) if p.startswith(rest)]
if ((len(res) > 1) or (not os.path.exists(path))):
return res
if os.path.isdir(path):
return [p for p in _listdir(path)]
return [(path + ' ')]
|
[
"def",
"_complete_path",
"(",
"path",
"=",
"None",
")",
":",
"if",
"(",
"not",
"path",
")",
":",
"return",
"_listdir",
"(",
"'.'",
")",
"(",
"dirname",
",",
"rest",
")",
"=",
"os",
".",
"path",
".",
"split",
"(",
"path",
")",
"tmp",
"=",
"(",
"dirname",
"if",
"dirname",
"else",
"'.'",
")",
"res",
"=",
"[",
"p",
"for",
"p",
"in",
"_listdir",
"(",
"tmp",
")",
"if",
"p",
".",
"startswith",
"(",
"rest",
")",
"]",
"if",
"(",
"(",
"len",
"(",
"res",
")",
">",
"1",
")",
"or",
"(",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
")",
")",
":",
"return",
"res",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"return",
"[",
"p",
"for",
"p",
"in",
"_listdir",
"(",
"path",
")",
"]",
"return",
"[",
"(",
"path",
"+",
"' '",
")",
"]"
] |
perform completion of filesystem path .
|
train
| true
|
8,286
|
def bin(number):
tmp = [BIN_HEX_DICT[hstr] for hstr in hex(number)[2:]]
return BIN_ZSTRIP.sub('0b', ''.join(tmp))
|
[
"def",
"bin",
"(",
"number",
")",
":",
"tmp",
"=",
"[",
"BIN_HEX_DICT",
"[",
"hstr",
"]",
"for",
"hstr",
"in",
"hex",
"(",
"number",
")",
"[",
"2",
":",
"]",
"]",
"return",
"BIN_ZSTRIP",
".",
"sub",
"(",
"'0b'",
",",
"''",
".",
"join",
"(",
"tmp",
")",
")"
] |
returns a dictionary with items in the given list grouped by the given key .
|
train
| false
|
8,288
|
def repanel_cov(groups, sigmas):
if (groups.ndim == 1):
groups = groups[:, None]
(nobs, nre) = groups.shape
omega = (sigmas[(-1)] * np.eye(nobs))
for igr in range(nre):
group = groups[:, igr:(igr + 1)]
groupuniq = np.unique(group)
dummygr = (sigmas[igr] * (group == groupuniq).astype(float))
omega += np.dot(dummygr, dummygr.T)
(ev, evec) = np.linalg.eigh(omega)
omegainv = np.dot(evec, ((1 / ev) * evec).T)
omegainvhalf = (evec / np.sqrt(ev))
return (omega, omegainv, omegainvhalf)
|
[
"def",
"repanel_cov",
"(",
"groups",
",",
"sigmas",
")",
":",
"if",
"(",
"groups",
".",
"ndim",
"==",
"1",
")",
":",
"groups",
"=",
"groups",
"[",
":",
",",
"None",
"]",
"(",
"nobs",
",",
"nre",
")",
"=",
"groups",
".",
"shape",
"omega",
"=",
"(",
"sigmas",
"[",
"(",
"-",
"1",
")",
"]",
"*",
"np",
".",
"eye",
"(",
"nobs",
")",
")",
"for",
"igr",
"in",
"range",
"(",
"nre",
")",
":",
"group",
"=",
"groups",
"[",
":",
",",
"igr",
":",
"(",
"igr",
"+",
"1",
")",
"]",
"groupuniq",
"=",
"np",
".",
"unique",
"(",
"group",
")",
"dummygr",
"=",
"(",
"sigmas",
"[",
"igr",
"]",
"*",
"(",
"group",
"==",
"groupuniq",
")",
".",
"astype",
"(",
"float",
")",
")",
"omega",
"+=",
"np",
".",
"dot",
"(",
"dummygr",
",",
"dummygr",
".",
"T",
")",
"(",
"ev",
",",
"evec",
")",
"=",
"np",
".",
"linalg",
".",
"eigh",
"(",
"omega",
")",
"omegainv",
"=",
"np",
".",
"dot",
"(",
"evec",
",",
"(",
"(",
"1",
"/",
"ev",
")",
"*",
"evec",
")",
".",
"T",
")",
"omegainvhalf",
"=",
"(",
"evec",
"/",
"np",
".",
"sqrt",
"(",
"ev",
")",
")",
"return",
"(",
"omega",
",",
"omegainv",
",",
"omegainvhalf",
")"
] |
calculate error covariance matrix for random effects model parameters groups : array .
|
train
| false
|
8,289
|
def no_vtk():
global _vtk_version
return (_vtk_version is None)
|
[
"def",
"no_vtk",
"(",
")",
":",
"global",
"_vtk_version",
"return",
"(",
"_vtk_version",
"is",
"None",
")"
] |
checks if vtk is installed and the python wrapper is functional .
|
train
| false
|
8,291
|
def log_events(klass):
old_event = klass.event
@functools.wraps(old_event)
def new_event(self, e, *args, **kwargs):
'Wrapper for event() which logs events.'
log.misc.debug('Event in {}: {}'.format(utils.qualname(klass), qenum_key(QEvent, e.type())))
return old_event(self, e, *args, **kwargs)
klass.event = new_event
return klass
|
[
"def",
"log_events",
"(",
"klass",
")",
":",
"old_event",
"=",
"klass",
".",
"event",
"@",
"functools",
".",
"wraps",
"(",
"old_event",
")",
"def",
"new_event",
"(",
"self",
",",
"e",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"log",
".",
"misc",
".",
"debug",
"(",
"'Event in {}: {}'",
".",
"format",
"(",
"utils",
".",
"qualname",
"(",
"klass",
")",
",",
"qenum_key",
"(",
"QEvent",
",",
"e",
".",
"type",
"(",
")",
")",
")",
")",
"return",
"old_event",
"(",
"self",
",",
"e",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"klass",
".",
"event",
"=",
"new_event",
"return",
"klass"
] |
class decorator to log qt events .
|
train
| false
|
8,292
|
def test_majority_label_iris():
clf1 = LogisticRegression(random_state=123)
clf2 = RandomForestClassifier(random_state=123)
clf3 = GaussianNB()
eclf = VotingClassifier(estimators=[('lr', clf1), ('rf', clf2), ('gnb', clf3)], voting='hard')
scores = cross_val_score(eclf, X, y, cv=5, scoring='accuracy')
assert_almost_equal(scores.mean(), 0.95, decimal=2)
|
[
"def",
"test_majority_label_iris",
"(",
")",
":",
"clf1",
"=",
"LogisticRegression",
"(",
"random_state",
"=",
"123",
")",
"clf2",
"=",
"RandomForestClassifier",
"(",
"random_state",
"=",
"123",
")",
"clf3",
"=",
"GaussianNB",
"(",
")",
"eclf",
"=",
"VotingClassifier",
"(",
"estimators",
"=",
"[",
"(",
"'lr'",
",",
"clf1",
")",
",",
"(",
"'rf'",
",",
"clf2",
")",
",",
"(",
"'gnb'",
",",
"clf3",
")",
"]",
",",
"voting",
"=",
"'hard'",
")",
"scores",
"=",
"cross_val_score",
"(",
"eclf",
",",
"X",
",",
"y",
",",
"cv",
"=",
"5",
",",
"scoring",
"=",
"'accuracy'",
")",
"assert_almost_equal",
"(",
"scores",
".",
"mean",
"(",
")",
",",
"0.95",
",",
"decimal",
"=",
"2",
")"
] |
check classification by majority label on dataset iris .
|
train
| false
|
8,293
|
def _re_compile(regex):
return re.compile(regex, (re.I | re.UNICODE))
|
[
"def",
"_re_compile",
"(",
"regex",
")",
":",
"return",
"re",
".",
"compile",
"(",
"regex",
",",
"(",
"re",
".",
"I",
"|",
"re",
".",
"UNICODE",
")",
")"
] |
compile a string to regex .
|
train
| false
|
8,294
|
def get_package_name(filepath):
pkg_name = []
while (('site-packages' in filepath) or ('dist-packages' in filepath)):
(filepath, p2) = os.path.split(filepath)
if (p2 in ('site-packages', 'dist-packages')):
break
pkg_name.append(p2)
if (not pkg_name):
return 'pandas'
pkg_name.reverse()
if pkg_name[0].endswith('.egg'):
pkg_name.pop(0)
return '.'.join(pkg_name)
|
[
"def",
"get_package_name",
"(",
"filepath",
")",
":",
"pkg_name",
"=",
"[",
"]",
"while",
"(",
"(",
"'site-packages'",
"in",
"filepath",
")",
"or",
"(",
"'dist-packages'",
"in",
"filepath",
")",
")",
":",
"(",
"filepath",
",",
"p2",
")",
"=",
"os",
".",
"path",
".",
"split",
"(",
"filepath",
")",
"if",
"(",
"p2",
"in",
"(",
"'site-packages'",
",",
"'dist-packages'",
")",
")",
":",
"break",
"pkg_name",
".",
"append",
"(",
"p2",
")",
"if",
"(",
"not",
"pkg_name",
")",
":",
"return",
"'pandas'",
"pkg_name",
".",
"reverse",
"(",
")",
"if",
"pkg_name",
"[",
"0",
"]",
".",
"endswith",
"(",
"'.egg'",
")",
":",
"pkg_name",
".",
"pop",
"(",
"0",
")",
"return",
"'.'",
".",
"join",
"(",
"pkg_name",
")"
] |
get "name" from a package with a workaround when its not defined .
|
train
| false
|
8,295
|
def _range_string_to_set(range_str):
if ('..' in range_str):
(range_start, range_end) = range_str.split('..')
range_start = int(range_start, 16)
range_end = int(range_end, 16)
return set(range(range_start, (range_end + 1)))
else:
return {int(range_str, 16)}
|
[
"def",
"_range_string_to_set",
"(",
"range_str",
")",
":",
"if",
"(",
"'..'",
"in",
"range_str",
")",
":",
"(",
"range_start",
",",
"range_end",
")",
"=",
"range_str",
".",
"split",
"(",
"'..'",
")",
"range_start",
"=",
"int",
"(",
"range_start",
",",
"16",
")",
"range_end",
"=",
"int",
"(",
"range_end",
",",
"16",
")",
"return",
"set",
"(",
"range",
"(",
"range_start",
",",
"(",
"range_end",
"+",
"1",
")",
")",
")",
"else",
":",
"return",
"{",
"int",
"(",
"range_str",
",",
"16",
")",
"}"
] |
convert a range encoding in a string to a set .
|
train
| false
|
8,296
|
def parse_stats(conf, json):
'Ignore stats if coming from non-leading mesos master'
elected_result = lookup_stat('master/elected', json, conf)
if (elected_result == 1):
for (name, key) in get_stats_string(conf['version']).iteritems():
result = lookup_stat(name, json, conf)
dispatch_stat(result, name, key, conf)
else:
log_verbose(conf['verboseLogging'], 'This mesos master node is not elected leader so not writing data.')
return None
|
[
"def",
"parse_stats",
"(",
"conf",
",",
"json",
")",
":",
"elected_result",
"=",
"lookup_stat",
"(",
"'master/elected'",
",",
"json",
",",
"conf",
")",
"if",
"(",
"elected_result",
"==",
"1",
")",
":",
"for",
"(",
"name",
",",
"key",
")",
"in",
"get_stats_string",
"(",
"conf",
"[",
"'version'",
"]",
")",
".",
"iteritems",
"(",
")",
":",
"result",
"=",
"lookup_stat",
"(",
"name",
",",
"json",
",",
"conf",
")",
"dispatch_stat",
"(",
"result",
",",
"name",
",",
"key",
",",
"conf",
")",
"else",
":",
"log_verbose",
"(",
"conf",
"[",
"'verboseLogging'",
"]",
",",
"'This mesos master node is not elected leader so not writing data.'",
")",
"return",
"None"
] |
parse stats response from mesos slave .
|
train
| false
|
8,297
|
def member_list(context, data_dict=None):
model = context['model']
group = model.Group.get(_get_or_bust(data_dict, 'id'))
if (not group):
raise NotFound
obj_type = data_dict.get('object_type', None)
capacity = data_dict.get('capacity', None)
_check_access('group_show', context, data_dict)
q = model.Session.query(model.Member).filter((model.Member.group_id == group.id)).filter((model.Member.state == 'active'))
if obj_type:
q = q.filter((model.Member.table_name == obj_type))
if capacity:
q = q.filter((model.Member.capacity == capacity))
trans = authz.roles_trans()
def translated_capacity(capacity):
try:
return trans[capacity]
except KeyError:
return capacity
return [(m.table_id, m.table_name, translated_capacity(m.capacity)) for m in q.all()]
|
[
"def",
"member_list",
"(",
"context",
",",
"data_dict",
"=",
"None",
")",
":",
"model",
"=",
"context",
"[",
"'model'",
"]",
"group",
"=",
"model",
".",
"Group",
".",
"get",
"(",
"_get_or_bust",
"(",
"data_dict",
",",
"'id'",
")",
")",
"if",
"(",
"not",
"group",
")",
":",
"raise",
"NotFound",
"obj_type",
"=",
"data_dict",
".",
"get",
"(",
"'object_type'",
",",
"None",
")",
"capacity",
"=",
"data_dict",
".",
"get",
"(",
"'capacity'",
",",
"None",
")",
"_check_access",
"(",
"'group_show'",
",",
"context",
",",
"data_dict",
")",
"q",
"=",
"model",
".",
"Session",
".",
"query",
"(",
"model",
".",
"Member",
")",
".",
"filter",
"(",
"(",
"model",
".",
"Member",
".",
"group_id",
"==",
"group",
".",
"id",
")",
")",
".",
"filter",
"(",
"(",
"model",
".",
"Member",
".",
"state",
"==",
"'active'",
")",
")",
"if",
"obj_type",
":",
"q",
"=",
"q",
".",
"filter",
"(",
"(",
"model",
".",
"Member",
".",
"table_name",
"==",
"obj_type",
")",
")",
"if",
"capacity",
":",
"q",
"=",
"q",
".",
"filter",
"(",
"(",
"model",
".",
"Member",
".",
"capacity",
"==",
"capacity",
")",
")",
"trans",
"=",
"authz",
".",
"roles_trans",
"(",
")",
"def",
"translated_capacity",
"(",
"capacity",
")",
":",
"try",
":",
"return",
"trans",
"[",
"capacity",
"]",
"except",
"KeyError",
":",
"return",
"capacity",
"return",
"[",
"(",
"m",
".",
"table_id",
",",
"m",
".",
"table_name",
",",
"translated_capacity",
"(",
"m",
".",
"capacity",
")",
")",
"for",
"m",
"in",
"q",
".",
"all",
"(",
")",
"]"
] |
return the members of a group .
|
train
| false
|
8,298
|
def _split_series_episode(title):
series_title = ''
episode_or_year = ''
if (title[(-1):] == '}'):
begin_eps = title.rfind('{')
if (begin_eps == (-1)):
return ('', '')
series_title = title[:begin_eps].rstrip()
episode_or_year = title[begin_eps:].strip()
if (episode_or_year[:12] == '{SUSPENDED}}'):
return ('', '')
elif (title[0:1] == '"'):
second_quot = (title[1:].find('"') + 2)
if (second_quot != 1):
episode_or_year = title[second_quot:].lstrip()
first_char = episode_or_year[0:1]
if (not first_char):
return ('', '')
if (first_char != '('):
series_title = title[:second_quot]
return (series_title, episode_or_year)
|
[
"def",
"_split_series_episode",
"(",
"title",
")",
":",
"series_title",
"=",
"''",
"episode_or_year",
"=",
"''",
"if",
"(",
"title",
"[",
"(",
"-",
"1",
")",
":",
"]",
"==",
"'}'",
")",
":",
"begin_eps",
"=",
"title",
".",
"rfind",
"(",
"'{'",
")",
"if",
"(",
"begin_eps",
"==",
"(",
"-",
"1",
")",
")",
":",
"return",
"(",
"''",
",",
"''",
")",
"series_title",
"=",
"title",
"[",
":",
"begin_eps",
"]",
".",
"rstrip",
"(",
")",
"episode_or_year",
"=",
"title",
"[",
"begin_eps",
":",
"]",
".",
"strip",
"(",
")",
"if",
"(",
"episode_or_year",
"[",
":",
"12",
"]",
"==",
"'{SUSPENDED}}'",
")",
":",
"return",
"(",
"''",
",",
"''",
")",
"elif",
"(",
"title",
"[",
"0",
":",
"1",
"]",
"==",
"'\"'",
")",
":",
"second_quot",
"=",
"(",
"title",
"[",
"1",
":",
"]",
".",
"find",
"(",
"'\"'",
")",
"+",
"2",
")",
"if",
"(",
"second_quot",
"!=",
"1",
")",
":",
"episode_or_year",
"=",
"title",
"[",
"second_quot",
":",
"]",
".",
"lstrip",
"(",
")",
"first_char",
"=",
"episode_or_year",
"[",
"0",
":",
"1",
"]",
"if",
"(",
"not",
"first_char",
")",
":",
"return",
"(",
"''",
",",
"''",
")",
"if",
"(",
"first_char",
"!=",
"'('",
")",
":",
"series_title",
"=",
"title",
"[",
":",
"second_quot",
"]",
"return",
"(",
"series_title",
",",
"episode_or_year",
")"
] |
return the series and the episode titles; if this is not a series episode .
|
train
| false
|
8,300
|
def setup_package():
util.positional_parameters_enforcement = 'EXCEPTION'
|
[
"def",
"setup_package",
"(",
")",
":",
"util",
".",
"positional_parameters_enforcement",
"=",
"'EXCEPTION'"
] |
run on testing package .
|
train
| false
|
8,301
|
def get_map(options, data):
try:
map_f = open(options.map_fname, 'U').readlines()
except (TypeError, IOError):
raise MissingFileError('Mapping file required for this analysis')
data['map'] = parse_mapping_file(map_f)
return data['map']
|
[
"def",
"get_map",
"(",
"options",
",",
"data",
")",
":",
"try",
":",
"map_f",
"=",
"open",
"(",
"options",
".",
"map_fname",
",",
"'U'",
")",
".",
"readlines",
"(",
")",
"except",
"(",
"TypeError",
",",
"IOError",
")",
":",
"raise",
"MissingFileError",
"(",
"'Mapping file required for this analysis'",
")",
"data",
"[",
"'map'",
"]",
"=",
"parse_mapping_file",
"(",
"map_f",
")",
"return",
"data",
"[",
"'map'",
"]"
] |
opens and returns mapping data .
|
train
| false
|
8,302
|
def load_module_from_name(dotted_name, path=None, use_sys=1):
return load_module_from_modpath(dotted_name.split('.'), path, use_sys)
|
[
"def",
"load_module_from_name",
"(",
"dotted_name",
",",
"path",
"=",
"None",
",",
"use_sys",
"=",
"1",
")",
":",
"return",
"load_module_from_modpath",
"(",
"dotted_name",
".",
"split",
"(",
"'.'",
")",
",",
"path",
",",
"use_sys",
")"
] |
load a python module from its name .
|
train
| true
|
8,304
|
def pass_context(f):
def new_func(*args, **kwargs):
return f(get_current_context(), *args, **kwargs)
return update_wrapper(new_func, f)
|
[
"def",
"pass_context",
"(",
"f",
")",
":",
"def",
"new_func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"return",
"f",
"(",
"get_current_context",
"(",
")",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"return",
"update_wrapper",
"(",
"new_func",
",",
"f",
")"
] |
marks a callback as wanting to receive the current context object as first argument .
|
train
| true
|
8,305
|
def exception_to_nan(func):
def wrap(*a, **kw):
try:
return func(*a, **kw)
except Exception:
return np.nan
return wrap
|
[
"def",
"exception_to_nan",
"(",
"func",
")",
":",
"def",
"wrap",
"(",
"*",
"a",
",",
"**",
"kw",
")",
":",
"try",
":",
"return",
"func",
"(",
"*",
"a",
",",
"**",
"kw",
")",
"except",
"Exception",
":",
"return",
"np",
".",
"nan",
"return",
"wrap"
] |
decorate function to return nan if it raises an exception .
|
train
| false
|
8,306
|
def ntop(address):
af = (((len(address) == 4) and socket.AF_INET) or socket.AF_INET6)
return socket.inet_ntop(af, address)
|
[
"def",
"ntop",
"(",
"address",
")",
":",
"af",
"=",
"(",
"(",
"(",
"len",
"(",
"address",
")",
"==",
"4",
")",
"and",
"socket",
".",
"AF_INET",
")",
"or",
"socket",
".",
"AF_INET6",
")",
"return",
"socket",
".",
"inet_ntop",
"(",
"af",
",",
"address",
")"
] |
convert address to its string representation .
|
train
| false
|
8,307
|
def _convert_paths(paths):
new_paths = []
for path in paths:
new_path = _convert_2to3(path)
new_paths.append(new_path)
return new_paths
|
[
"def",
"_convert_paths",
"(",
"paths",
")",
":",
"new_paths",
"=",
"[",
"]",
"for",
"path",
"in",
"paths",
":",
"new_path",
"=",
"_convert_2to3",
"(",
"path",
")",
"new_paths",
".",
"append",
"(",
"new_path",
")",
"return",
"new_paths"
] |
convert the given files .
|
train
| false
|
8,308
|
def _rgb_to_hex(rgbs):
(rgbs, n_dim) = _check_color_dim(rgbs)
return np.array([('#%02x%02x%02x' % tuple((255 * rgb[:3]).astype(np.uint8))) for rgb in rgbs], '|U7')
|
[
"def",
"_rgb_to_hex",
"(",
"rgbs",
")",
":",
"(",
"rgbs",
",",
"n_dim",
")",
"=",
"_check_color_dim",
"(",
"rgbs",
")",
"return",
"np",
".",
"array",
"(",
"[",
"(",
"'#%02x%02x%02x'",
"%",
"tuple",
"(",
"(",
"255",
"*",
"rgb",
"[",
":",
"3",
"]",
")",
".",
"astype",
"(",
"np",
".",
"uint8",
")",
")",
")",
"for",
"rgb",
"in",
"rgbs",
"]",
",",
"'|U7'",
")"
] |
convert rgb to hex triplet .
|
train
| true
|
8,309
|
def argmax(seq, func):
return max(seq, key=func)
|
[
"def",
"argmax",
"(",
"seq",
",",
"func",
")",
":",
"return",
"max",
"(",
"seq",
",",
"key",
"=",
"func",
")"
] |
returns the indices of the maximum along an axis .
|
train
| false
|
8,310
|
def oo_31_rpm_rename_conversion(rpms, openshift_version=None):
if (not isinstance(rpms, list)):
raise errors.AnsibleFilterError('failed expects to filter on a list')
if ((openshift_version is not None) and (not isinstance(openshift_version, string_types))):
raise errors.AnsibleFilterError('failed expects openshift_version to be a string')
rpms_31 = []
for rpm in rpms:
if ('atomic' not in rpm):
rpm = rpm.replace('openshift', 'atomic-openshift')
if openshift_version:
rpm = (rpm + openshift_version)
rpms_31.append(rpm)
return rpms_31
|
[
"def",
"oo_31_rpm_rename_conversion",
"(",
"rpms",
",",
"openshift_version",
"=",
"None",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"rpms",
",",
"list",
")",
")",
":",
"raise",
"errors",
".",
"AnsibleFilterError",
"(",
"'failed expects to filter on a list'",
")",
"if",
"(",
"(",
"openshift_version",
"is",
"not",
"None",
")",
"and",
"(",
"not",
"isinstance",
"(",
"openshift_version",
",",
"string_types",
")",
")",
")",
":",
"raise",
"errors",
".",
"AnsibleFilterError",
"(",
"'failed expects openshift_version to be a string'",
")",
"rpms_31",
"=",
"[",
"]",
"for",
"rpm",
"in",
"rpms",
":",
"if",
"(",
"'atomic'",
"not",
"in",
"rpm",
")",
":",
"rpm",
"=",
"rpm",
".",
"replace",
"(",
"'openshift'",
",",
"'atomic-openshift'",
")",
"if",
"openshift_version",
":",
"rpm",
"=",
"(",
"rpm",
"+",
"openshift_version",
")",
"rpms_31",
".",
"append",
"(",
"rpm",
")",
"return",
"rpms_31"
] |
filters a list of 3 .
|
train
| false
|
8,311
|
def normal_two_sided_bounds(probability, mu=0, sigma=1):
tail_probability = ((1 - probability) / 2)
upper_bound = normal_lower_bound(tail_probability, mu, sigma)
lower_bound = normal_upper_bound(tail_probability, mu, sigma)
return (lower_bound, upper_bound)
|
[
"def",
"normal_two_sided_bounds",
"(",
"probability",
",",
"mu",
"=",
"0",
",",
"sigma",
"=",
"1",
")",
":",
"tail_probability",
"=",
"(",
"(",
"1",
"-",
"probability",
")",
"/",
"2",
")",
"upper_bound",
"=",
"normal_lower_bound",
"(",
"tail_probability",
",",
"mu",
",",
"sigma",
")",
"lower_bound",
"=",
"normal_upper_bound",
"(",
"tail_probability",
",",
"mu",
",",
"sigma",
")",
"return",
"(",
"lower_bound",
",",
"upper_bound",
")"
] |
returns the symmetric bounds that contain the specified probability .
|
train
| false
|
8,313
|
def _nova_to_osvif_ip(ip):
floating_ips = [fip['address'] for fip in ip.get('floating_ips', [])]
return objects.fixed_ip.FixedIP(address=ip['address'], floating_ips=floating_ips)
|
[
"def",
"_nova_to_osvif_ip",
"(",
"ip",
")",
":",
"floating_ips",
"=",
"[",
"fip",
"[",
"'address'",
"]",
"for",
"fip",
"in",
"ip",
".",
"get",
"(",
"'floating_ips'",
",",
"[",
"]",
")",
"]",
"return",
"objects",
".",
"fixed_ip",
".",
"FixedIP",
"(",
"address",
"=",
"ip",
"[",
"'address'",
"]",
",",
"floating_ips",
"=",
"floating_ips",
")"
] |
convert nova ip object into os_vif object .
|
train
| false
|
8,315
|
def test_get_init_2():
with make_tempfile(join(TMP_TEST_DIR, '__init__.pyw')):
assert mp.get_init(TMP_TEST_DIR)
|
[
"def",
"test_get_init_2",
"(",
")",
":",
"with",
"make_tempfile",
"(",
"join",
"(",
"TMP_TEST_DIR",
",",
"'__init__.pyw'",
")",
")",
":",
"assert",
"mp",
".",
"get_init",
"(",
"TMP_TEST_DIR",
")"
] |
see if get_init can find __init__ .
|
train
| false
|
8,317
|
def _SetConnection(connection):
__InitConnection()
_thread_local.connection_stack[(-1)] = connection
|
[
"def",
"_SetConnection",
"(",
"connection",
")",
":",
"__InitConnection",
"(",
")",
"_thread_local",
".",
"connection_stack",
"[",
"(",
"-",
"1",
")",
"]",
"=",
"connection"
] |
sets the datastore connection local to the thread .
|
train
| false
|
8,318
|
def find_outliers(X, threshold=3.0, max_iter=2):
from scipy.stats import zscore
my_mask = np.zeros(len(X), dtype=np.bool)
for _ in range(max_iter):
X = np.ma.masked_array(X, my_mask)
this_z = np.abs(zscore(X))
local_bad = (this_z > threshold)
my_mask = np.max([my_mask, local_bad], 0)
if (not np.any(local_bad)):
break
bad_idx = np.where(my_mask)[0]
return bad_idx
|
[
"def",
"find_outliers",
"(",
"X",
",",
"threshold",
"=",
"3.0",
",",
"max_iter",
"=",
"2",
")",
":",
"from",
"scipy",
".",
"stats",
"import",
"zscore",
"my_mask",
"=",
"np",
".",
"zeros",
"(",
"len",
"(",
"X",
")",
",",
"dtype",
"=",
"np",
".",
"bool",
")",
"for",
"_",
"in",
"range",
"(",
"max_iter",
")",
":",
"X",
"=",
"np",
".",
"ma",
".",
"masked_array",
"(",
"X",
",",
"my_mask",
")",
"this_z",
"=",
"np",
".",
"abs",
"(",
"zscore",
"(",
"X",
")",
")",
"local_bad",
"=",
"(",
"this_z",
">",
"threshold",
")",
"my_mask",
"=",
"np",
".",
"max",
"(",
"[",
"my_mask",
",",
"local_bad",
"]",
",",
"0",
")",
"if",
"(",
"not",
"np",
".",
"any",
"(",
"local_bad",
")",
")",
":",
"break",
"bad_idx",
"=",
"np",
".",
"where",
"(",
"my_mask",
")",
"[",
"0",
"]",
"return",
"bad_idx"
] |
find outliers based on iterated z-scoring .
|
train
| false
|
8,319
|
def get_entities(table, schema, db, first_key, last_key):
return db.range_query(table, schema, first_key, last_key, _MAX_ENTITIES)
|
[
"def",
"get_entities",
"(",
"table",
",",
"schema",
",",
"db",
",",
"first_key",
",",
"last_key",
")",
":",
"return",
"db",
".",
"range_query",
"(",
"table",
",",
"schema",
",",
"first_key",
",",
"last_key",
",",
"_MAX_ENTITIES",
")"
] |
gets entities from a table .
|
train
| false
|
8,320
|
def list_stack(profile=None):
ret = {}
h_client = _auth(profile)
for stack in h_client.stacks.list():
links = {}
for link in stack.links:
links[link['rel']] = link['href']
ret[stack.stack_name] = {'status': stack.stack_status, 'id': stack.id, 'name': stack.stack_name, 'creation': stack.creation_time, 'owner': stack.stack_owner, 'reason': stack.stack_status_reason, 'links': links}
return ret
|
[
"def",
"list_stack",
"(",
"profile",
"=",
"None",
")",
":",
"ret",
"=",
"{",
"}",
"h_client",
"=",
"_auth",
"(",
"profile",
")",
"for",
"stack",
"in",
"h_client",
".",
"stacks",
".",
"list",
"(",
")",
":",
"links",
"=",
"{",
"}",
"for",
"link",
"in",
"stack",
".",
"links",
":",
"links",
"[",
"link",
"[",
"'rel'",
"]",
"]",
"=",
"link",
"[",
"'href'",
"]",
"ret",
"[",
"stack",
".",
"stack_name",
"]",
"=",
"{",
"'status'",
":",
"stack",
".",
"stack_status",
",",
"'id'",
":",
"stack",
".",
"id",
",",
"'name'",
":",
"stack",
".",
"stack_name",
",",
"'creation'",
":",
"stack",
".",
"creation_time",
",",
"'owner'",
":",
"stack",
".",
"stack_owner",
",",
"'reason'",
":",
"stack",
".",
"stack_status_reason",
",",
"'links'",
":",
"links",
"}",
"return",
"ret"
] |
return a list of available stack profile profile to use cli example: .
|
train
| true
|
8,321
|
def index_delete(index, hosts=None, profile=None):
es = _get_instance(hosts, profile)
try:
if (not index_exists(index=index)):
return True
else:
result = es.indices.delete(index=index)
if result.get('acknowledged', False):
return True
except elasticsearch.exceptions.NotFoundError:
return None
return None
|
[
"def",
"index_delete",
"(",
"index",
",",
"hosts",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"es",
"=",
"_get_instance",
"(",
"hosts",
",",
"profile",
")",
"try",
":",
"if",
"(",
"not",
"index_exists",
"(",
"index",
"=",
"index",
")",
")",
":",
"return",
"True",
"else",
":",
"result",
"=",
"es",
".",
"indices",
".",
"delete",
"(",
"index",
"=",
"index",
")",
"if",
"result",
".",
"get",
"(",
"'acknowledged'",
",",
"False",
")",
":",
"return",
"True",
"except",
"elasticsearch",
".",
"exceptions",
".",
"NotFoundError",
":",
"return",
"None",
"return",
"None"
] |
delete an index cli example:: salt myminion elasticsearch .
|
train
| false
|
8,322
|
def escape_unicode(string):
returnValue = StringIO()
for character in string:
code = ord(character)
if (code > 127):
hexCode = hex(code)
returnValue.write(((('%' + hexCode[2:4]) + '%') + hexCode[4:6]))
else:
returnValue.write(character)
return returnValue.getvalue()
|
[
"def",
"escape_unicode",
"(",
"string",
")",
":",
"returnValue",
"=",
"StringIO",
"(",
")",
"for",
"character",
"in",
"string",
":",
"code",
"=",
"ord",
"(",
"character",
")",
"if",
"(",
"code",
">",
"127",
")",
":",
"hexCode",
"=",
"hex",
"(",
"code",
")",
"returnValue",
".",
"write",
"(",
"(",
"(",
"(",
"'%'",
"+",
"hexCode",
"[",
"2",
":",
"4",
"]",
")",
"+",
"'%'",
")",
"+",
"hexCode",
"[",
"4",
":",
"6",
"]",
")",
")",
"else",
":",
"returnValue",
".",
"write",
"(",
"character",
")",
"return",
"returnValue",
".",
"getvalue",
"(",
")"
] |
converts a unicode string into us-ascii .
|
train
| false
|
8,325
|
def test_bookmark_completion(qtmodeltester, bookmarks):
model = miscmodels.BookmarkCompletionModel()
qtmodeltester.data_display_may_return_none = True
qtmodeltester.check(model)
_check_completions(model, {'Bookmarks': [('https://github.com', 'GitHub', ''), ('https://python.org', 'Welcome to Python.org', ''), ('http://qutebrowser.org', 'qutebrowser | qutebrowser', '')]})
|
[
"def",
"test_bookmark_completion",
"(",
"qtmodeltester",
",",
"bookmarks",
")",
":",
"model",
"=",
"miscmodels",
".",
"BookmarkCompletionModel",
"(",
")",
"qtmodeltester",
".",
"data_display_may_return_none",
"=",
"True",
"qtmodeltester",
".",
"check",
"(",
"model",
")",
"_check_completions",
"(",
"model",
",",
"{",
"'Bookmarks'",
":",
"[",
"(",
"'https://github.com'",
",",
"'GitHub'",
",",
"''",
")",
",",
"(",
"'https://python.org'",
",",
"'Welcome to Python.org'",
",",
"''",
")",
",",
"(",
"'http://qutebrowser.org'",
",",
"'qutebrowser | qutebrowser'",
",",
"''",
")",
"]",
"}",
")"
] |
test the results of bookmark completion .
|
train
| false
|
8,327
|
def case_i(string):
return ''.join([(((('[' + c.upper()) + c.lower()) + ']') if c.isalpha() else c) for c in re.escape(string)])
|
[
"def",
"case_i",
"(",
"string",
")",
":",
"return",
"''",
".",
"join",
"(",
"[",
"(",
"(",
"(",
"(",
"'['",
"+",
"c",
".",
"upper",
"(",
")",
")",
"+",
"c",
".",
"lower",
"(",
")",
")",
"+",
"']'",
")",
"if",
"c",
".",
"isalpha",
"(",
")",
"else",
"c",
")",
"for",
"c",
"in",
"re",
".",
"escape",
"(",
"string",
")",
"]",
")"
] |
returns case insensitive regex .
|
train
| false
|
8,328
|
def make_path_recipe(r):
return ('/recipes/' + r)
|
[
"def",
"make_path_recipe",
"(",
"r",
")",
":",
"return",
"(",
"'/recipes/'",
"+",
"r",
")"
] |
converts a recipe id into a beaker path .
|
train
| false
|
8,330
|
@requires_segment_info
def file_name(pl, segment_info, display_no_file=False, no_file_text=u'[No file]'):
name = buffer_name(segment_info)
if (not name):
if display_no_file:
return [{u'contents': no_file_text, u'highlight_groups': [u'file_name_no_file', u'file_name']}]
else:
return None
return os.path.basename(name).decode(segment_info[u'encoding'], u'powerline_vim_strtrans_error')
|
[
"@",
"requires_segment_info",
"def",
"file_name",
"(",
"pl",
",",
"segment_info",
",",
"display_no_file",
"=",
"False",
",",
"no_file_text",
"=",
"u'[No file]'",
")",
":",
"name",
"=",
"buffer_name",
"(",
"segment_info",
")",
"if",
"(",
"not",
"name",
")",
":",
"if",
"display_no_file",
":",
"return",
"[",
"{",
"u'contents'",
":",
"no_file_text",
",",
"u'highlight_groups'",
":",
"[",
"u'file_name_no_file'",
",",
"u'file_name'",
"]",
"}",
"]",
"else",
":",
"return",
"None",
"return",
"os",
".",
"path",
".",
"basename",
"(",
"name",
")",
".",
"decode",
"(",
"segment_info",
"[",
"u'encoding'",
"]",
",",
"u'powerline_vim_strtrans_error'",
")"
] |
return file name .
|
train
| false
|
8,331
|
def abs(a):
return _abs(a)
|
[
"def",
"abs",
"(",
"a",
")",
":",
"return",
"_abs",
"(",
"a",
")"
] |
apply abs to each element of the matrix mat .
|
train
| false
|
8,334
|
def _append_package_paths(manifest_, paths, pkg_dir):
exports = manifest_.get_export('python', 'path')
if exports:
for export in exports:
if (':' in export):
export = export.split(':')
else:
export = [export]
for e in export:
paths.append(e.replace('${prefix}', pkg_dir))
else:
dirs = [os.path.join(pkg_dir, d) for d in ['src', 'lib']]
paths.extend([d for d in dirs if os.path.isdir(d)])
|
[
"def",
"_append_package_paths",
"(",
"manifest_",
",",
"paths",
",",
"pkg_dir",
")",
":",
"exports",
"=",
"manifest_",
".",
"get_export",
"(",
"'python'",
",",
"'path'",
")",
"if",
"exports",
":",
"for",
"export",
"in",
"exports",
":",
"if",
"(",
"':'",
"in",
"export",
")",
":",
"export",
"=",
"export",
".",
"split",
"(",
"':'",
")",
"else",
":",
"export",
"=",
"[",
"export",
"]",
"for",
"e",
"in",
"export",
":",
"paths",
".",
"append",
"(",
"e",
".",
"replace",
"(",
"'${prefix}'",
",",
"pkg_dir",
")",
")",
"else",
":",
"dirs",
"=",
"[",
"os",
".",
"path",
".",
"join",
"(",
"pkg_dir",
",",
"d",
")",
"for",
"d",
"in",
"[",
"'src'",
",",
"'lib'",
"]",
"]",
"paths",
".",
"extend",
"(",
"[",
"d",
"for",
"d",
"in",
"dirs",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"d",
")",
"]",
")"
] |
added paths for package to paths .
|
train
| false
|
8,336
|
@pytest.mark.usefixtures('break_getuser')
@pytest.mark.skipif(sys.platform.startswith('win'), reason='no os.getuid on windows')
def test_get_user_uid_not_found():
from _pytest.tmpdir import get_user
assert (get_user() is None)
|
[
"@",
"pytest",
".",
"mark",
".",
"usefixtures",
"(",
"'break_getuser'",
")",
"@",
"pytest",
".",
"mark",
".",
"skipif",
"(",
"sys",
".",
"platform",
".",
"startswith",
"(",
"'win'",
")",
",",
"reason",
"=",
"'no os.getuid on windows'",
")",
"def",
"test_get_user_uid_not_found",
"(",
")",
":",
"from",
"_pytest",
".",
"tmpdir",
"import",
"get_user",
"assert",
"(",
"get_user",
"(",
")",
"is",
"None",
")"
] |
test that get_user() function works even if the current processs user id does not correspond to a valid user (e .
|
train
| false
|
8,338
|
def create_size_estimators():
def line_count(filename):
with open(filename, u'rb') as fh:
return sum((1 for line in fh))
return {u'linecount': (lambda srcs: sum((line_count(src) for src in srcs))), u'filecount': (lambda srcs: len(srcs)), u'filesize': (lambda srcs: sum((os.path.getsize(src) for src in srcs))), u'nosize': (lambda srcs: 0), u'random': (lambda srcs: random.randint(0, 10000))}
|
[
"def",
"create_size_estimators",
"(",
")",
":",
"def",
"line_count",
"(",
"filename",
")",
":",
"with",
"open",
"(",
"filename",
",",
"u'rb'",
")",
"as",
"fh",
":",
"return",
"sum",
"(",
"(",
"1",
"for",
"line",
"in",
"fh",
")",
")",
"return",
"{",
"u'linecount'",
":",
"(",
"lambda",
"srcs",
":",
"sum",
"(",
"(",
"line_count",
"(",
"src",
")",
"for",
"src",
"in",
"srcs",
")",
")",
")",
",",
"u'filecount'",
":",
"(",
"lambda",
"srcs",
":",
"len",
"(",
"srcs",
")",
")",
",",
"u'filesize'",
":",
"(",
"lambda",
"srcs",
":",
"sum",
"(",
"(",
"os",
".",
"path",
".",
"getsize",
"(",
"src",
")",
"for",
"src",
"in",
"srcs",
")",
")",
")",
",",
"u'nosize'",
":",
"(",
"lambda",
"srcs",
":",
"0",
")",
",",
"u'random'",
":",
"(",
"lambda",
"srcs",
":",
"random",
".",
"randint",
"(",
"0",
",",
"10000",
")",
")",
"}"
] |
create a dict of name to a function that returns an estimated size for a given target .
|
train
| false
|
8,339
|
def HeaderPrints(message):
m = HeaderPrintMTADetails(message)
u = HeaderPrintMUADetails(message, mta=m)[:20]
g = HeaderPrintGenericDetails(message)[:50]
mua = (u[1] if u else None)
if (mua and mua.startswith('Mozilla ')):
mua = mua.split()[(-1)]
return {'sender': md5_hex('\n'.join(((m + u) + g))), 'tools': md5_hex('\n'.join((u + g))), 'mua': mua}
|
[
"def",
"HeaderPrints",
"(",
"message",
")",
":",
"m",
"=",
"HeaderPrintMTADetails",
"(",
"message",
")",
"u",
"=",
"HeaderPrintMUADetails",
"(",
"message",
",",
"mta",
"=",
"m",
")",
"[",
":",
"20",
"]",
"g",
"=",
"HeaderPrintGenericDetails",
"(",
"message",
")",
"[",
":",
"50",
"]",
"mua",
"=",
"(",
"u",
"[",
"1",
"]",
"if",
"u",
"else",
"None",
")",
"if",
"(",
"mua",
"and",
"mua",
".",
"startswith",
"(",
"'Mozilla '",
")",
")",
":",
"mua",
"=",
"mua",
".",
"split",
"(",
")",
"[",
"(",
"-",
"1",
")",
"]",
"return",
"{",
"'sender'",
":",
"md5_hex",
"(",
"'\\n'",
".",
"join",
"(",
"(",
"(",
"m",
"+",
"u",
")",
"+",
"g",
")",
")",
")",
",",
"'tools'",
":",
"md5_hex",
"(",
"'\\n'",
".",
"join",
"(",
"(",
"u",
"+",
"g",
")",
")",
")",
",",
"'mua'",
":",
"mua",
"}"
] |
generate fingerprints from message headers which identifies the mua .
|
train
| false
|
8,340
|
def clusterstatus(request):
return render('clusterstatus.html', request, Cluster(request.jt))
|
[
"def",
"clusterstatus",
"(",
"request",
")",
":",
"return",
"render",
"(",
"'clusterstatus.html'",
",",
"request",
",",
"Cluster",
"(",
"request",
".",
"jt",
")",
")"
] |
we get here from /clusterstatus .
|
train
| false
|
8,341
|
def RunDecompiler(d, dx, decompiler, session=None):
if (decompiler != None):
androconf.debug('Decompiler ...')
decompiler = decompiler.lower()
if (decompiler == 'dex2jad'):
d.set_decompiler(DecompilerDex2Jad(d, androconf.CONF['PATH_DEX2JAR'], androconf.CONF['BIN_DEX2JAR'], androconf.CONF['PATH_JAD'], androconf.CONF['BIN_JAD'], androconf.CONF['TMP_DIRECTORY']))
elif (decompiler == 'dex2fernflower'):
d.set_decompiler(DecompilerDex2Fernflower(d, androconf.CONF['PATH_DEX2JAR'], androconf.CONF['BIN_DEX2JAR'], androconf.CONF['PATH_FERNFLOWER'], androconf.CONF['BIN_FERNFLOWER'], androconf.CONF['OPTIONS_FERNFLOWER'], androconf.CONF['TMP_DIRECTORY']))
elif (decompiler == 'ded'):
d.set_decompiler(DecompilerDed(d, androconf.CONF['PATH_DED'], androconf.CONF['BIN_DED'], androconf.CONF['TMP_DIRECTORY']))
else:
d.set_decompiler(DecompilerDAD(d, dx))
|
[
"def",
"RunDecompiler",
"(",
"d",
",",
"dx",
",",
"decompiler",
",",
"session",
"=",
"None",
")",
":",
"if",
"(",
"decompiler",
"!=",
"None",
")",
":",
"androconf",
".",
"debug",
"(",
"'Decompiler ...'",
")",
"decompiler",
"=",
"decompiler",
".",
"lower",
"(",
")",
"if",
"(",
"decompiler",
"==",
"'dex2jad'",
")",
":",
"d",
".",
"set_decompiler",
"(",
"DecompilerDex2Jad",
"(",
"d",
",",
"androconf",
".",
"CONF",
"[",
"'PATH_DEX2JAR'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'BIN_DEX2JAR'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'PATH_JAD'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'BIN_JAD'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'TMP_DIRECTORY'",
"]",
")",
")",
"elif",
"(",
"decompiler",
"==",
"'dex2fernflower'",
")",
":",
"d",
".",
"set_decompiler",
"(",
"DecompilerDex2Fernflower",
"(",
"d",
",",
"androconf",
".",
"CONF",
"[",
"'PATH_DEX2JAR'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'BIN_DEX2JAR'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'PATH_FERNFLOWER'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'BIN_FERNFLOWER'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'OPTIONS_FERNFLOWER'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'TMP_DIRECTORY'",
"]",
")",
")",
"elif",
"(",
"decompiler",
"==",
"'ded'",
")",
":",
"d",
".",
"set_decompiler",
"(",
"DecompilerDed",
"(",
"d",
",",
"androconf",
".",
"CONF",
"[",
"'PATH_DED'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'BIN_DED'",
"]",
",",
"androconf",
".",
"CONF",
"[",
"'TMP_DIRECTORY'",
"]",
")",
")",
"else",
":",
"d",
".",
"set_decompiler",
"(",
"DecompilerDAD",
"(",
"d",
",",
"dx",
")",
")"
] |
run the decompiler on a specific analysis .
|
train
| false
|
8,342
|
def modprobe(mod):
return quietRun(['modprobe', mod])
|
[
"def",
"modprobe",
"(",
"mod",
")",
":",
"return",
"quietRun",
"(",
"[",
"'modprobe'",
",",
"mod",
"]",
")"
] |
return output of modprobe mod: module string .
|
train
| false
|
8,343
|
def test_horse():
horse = data.horse()
assert_equal(horse.ndim, 2)
assert_equal(horse.dtype, np.dtype('bool'))
|
[
"def",
"test_horse",
"(",
")",
":",
"horse",
"=",
"data",
".",
"horse",
"(",
")",
"assert_equal",
"(",
"horse",
".",
"ndim",
",",
"2",
")",
"assert_equal",
"(",
"horse",
".",
"dtype",
",",
"np",
".",
"dtype",
"(",
"'bool'",
")",
")"
] |
test that "horse" image can be loaded .
|
train
| false
|
8,345
|
def provides(interface):
interface_name = interface.__name__
def invariant(value):
if interface.providedBy(value):
return (True, '')
else:
return (False, "{value!r} doesn't provide {interface}".format(value=value, interface=interface_name))
invariant.__name__ = 'provides_{}_invariant'.format(interface_name)
return invariant
|
[
"def",
"provides",
"(",
"interface",
")",
":",
"interface_name",
"=",
"interface",
".",
"__name__",
"def",
"invariant",
"(",
"value",
")",
":",
"if",
"interface",
".",
"providedBy",
"(",
"value",
")",
":",
"return",
"(",
"True",
",",
"''",
")",
"else",
":",
"return",
"(",
"False",
",",
"\"{value!r} doesn't provide {interface}\"",
".",
"format",
"(",
"value",
"=",
"value",
",",
"interface",
"=",
"interface_name",
")",
")",
"invariant",
".",
"__name__",
"=",
"'provides_{}_invariant'",
".",
"format",
"(",
"interface_name",
")",
"return",
"invariant"
] |
create an invariant that asserts that the given value provides the given interface .
|
train
| false
|
8,346
|
def _import_module(importer, module_name, package):
if (module_name in sys.modules):
return sys.modules[module_name]
loader = importer.find_module(module_name)
if (loader is None):
return None
module = loader.load_module(module_name)
local_name = module_name.partition((package.__name__ + '.'))[2]
module_components = local_name.split('.')
parent = six.moves.reduce(getattr, module_components[:(-1)], package)
setattr(parent, module_components[(-1)], module)
return module
|
[
"def",
"_import_module",
"(",
"importer",
",",
"module_name",
",",
"package",
")",
":",
"if",
"(",
"module_name",
"in",
"sys",
".",
"modules",
")",
":",
"return",
"sys",
".",
"modules",
"[",
"module_name",
"]",
"loader",
"=",
"importer",
".",
"find_module",
"(",
"module_name",
")",
"if",
"(",
"loader",
"is",
"None",
")",
":",
"return",
"None",
"module",
"=",
"loader",
".",
"load_module",
"(",
"module_name",
")",
"local_name",
"=",
"module_name",
".",
"partition",
"(",
"(",
"package",
".",
"__name__",
"+",
"'.'",
")",
")",
"[",
"2",
"]",
"module_components",
"=",
"local_name",
".",
"split",
"(",
"'.'",
")",
"parent",
"=",
"six",
".",
"moves",
".",
"reduce",
"(",
"getattr",
",",
"module_components",
"[",
":",
"(",
"-",
"1",
")",
"]",
",",
"package",
")",
"setattr",
"(",
"parent",
",",
"module_components",
"[",
"(",
"-",
"1",
")",
"]",
",",
"module",
")",
"return",
"module"
] |
import module .
|
train
| false
|
8,347
|
def one_one_in_other(book_id_val_map, db, field, *args):
deleted = tuple(((k,) for (k, v) in book_id_val_map.iteritems() if (v is None)))
if deleted:
db.executemany((u'DELETE FROM %s WHERE book=?' % field.metadata[u'table']), deleted)
for book_id in deleted:
field.table.book_col_map.pop(book_id[0], None)
updated = {k: v for (k, v) in book_id_val_map.iteritems() if (v is not None)}
if updated:
db.executemany((u'INSERT OR REPLACE INTO %s(book,%s) VALUES (?,?)' % (field.metadata[u'table'], field.metadata[u'column'])), ((k, sqlite_datetime(v)) for (k, v) in updated.iteritems()))
field.table.book_col_map.update(updated)
return set(book_id_val_map)
|
[
"def",
"one_one_in_other",
"(",
"book_id_val_map",
",",
"db",
",",
"field",
",",
"*",
"args",
")",
":",
"deleted",
"=",
"tuple",
"(",
"(",
"(",
"k",
",",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"book_id_val_map",
".",
"iteritems",
"(",
")",
"if",
"(",
"v",
"is",
"None",
")",
")",
")",
"if",
"deleted",
":",
"db",
".",
"executemany",
"(",
"(",
"u'DELETE FROM %s WHERE book=?'",
"%",
"field",
".",
"metadata",
"[",
"u'table'",
"]",
")",
",",
"deleted",
")",
"for",
"book_id",
"in",
"deleted",
":",
"field",
".",
"table",
".",
"book_col_map",
".",
"pop",
"(",
"book_id",
"[",
"0",
"]",
",",
"None",
")",
"updated",
"=",
"{",
"k",
":",
"v",
"for",
"(",
"k",
",",
"v",
")",
"in",
"book_id_val_map",
".",
"iteritems",
"(",
")",
"if",
"(",
"v",
"is",
"not",
"None",
")",
"}",
"if",
"updated",
":",
"db",
".",
"executemany",
"(",
"(",
"u'INSERT OR REPLACE INTO %s(book,%s) VALUES (?,?)'",
"%",
"(",
"field",
".",
"metadata",
"[",
"u'table'",
"]",
",",
"field",
".",
"metadata",
"[",
"u'column'",
"]",
")",
")",
",",
"(",
"(",
"k",
",",
"sqlite_datetime",
"(",
"v",
")",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"updated",
".",
"iteritems",
"(",
")",
")",
")",
"field",
".",
"table",
".",
"book_col_map",
".",
"update",
"(",
"updated",
")",
"return",
"set",
"(",
"book_id_val_map",
")"
] |
set a one-one field in the non-books table .
|
train
| false
|
8,348
|
def create_logout_url(slug):
logout_url = utils.set_url_query_parameter('/logout', 'return_url', slug)
return logout_url
|
[
"def",
"create_logout_url",
"(",
"slug",
")",
":",
"logout_url",
"=",
"utils",
".",
"set_url_query_parameter",
"(",
"'/logout'",
",",
"'return_url'",
",",
"slug",
")",
"return",
"logout_url"
] |
computes the logout url for this request and specified destination url .
|
train
| false
|
8,349
|
def write_csv(results, headers, filename):
with open(filename, 'w') as csvfile:
writer = csv.DictWriter(csvfile, fieldnames=headers)
writer.writeheader()
writer.writerows(results)
|
[
"def",
"write_csv",
"(",
"results",
",",
"headers",
",",
"filename",
")",
":",
"with",
"open",
"(",
"filename",
",",
"'w'",
")",
"as",
"csvfile",
":",
"writer",
"=",
"csv",
".",
"DictWriter",
"(",
"csvfile",
",",
"fieldnames",
"=",
"headers",
")",
"writer",
".",
"writeheader",
"(",
")",
"writer",
".",
"writerows",
"(",
"results",
")"
] |
write a set of results to a csv file .
|
train
| false
|
8,350
|
def ensureDeferred(coro):
from types import GeneratorType
if (version_info >= (3, 4, 0)):
from asyncio import iscoroutine
if (iscoroutine(coro) or isinstance(coro, GeneratorType)):
return _inlineCallbacks(None, coro, Deferred())
elif (version_info >= (3, 3, 0)):
if isinstance(coro, GeneratorType):
return _inlineCallbacks(None, coro, Deferred())
if (not isinstance(coro, Deferred)):
raise ValueError(('%r is not a coroutine or a Deferred' % (coro,)))
return coro
|
[
"def",
"ensureDeferred",
"(",
"coro",
")",
":",
"from",
"types",
"import",
"GeneratorType",
"if",
"(",
"version_info",
">=",
"(",
"3",
",",
"4",
",",
"0",
")",
")",
":",
"from",
"asyncio",
"import",
"iscoroutine",
"if",
"(",
"iscoroutine",
"(",
"coro",
")",
"or",
"isinstance",
"(",
"coro",
",",
"GeneratorType",
")",
")",
":",
"return",
"_inlineCallbacks",
"(",
"None",
",",
"coro",
",",
"Deferred",
"(",
")",
")",
"elif",
"(",
"version_info",
">=",
"(",
"3",
",",
"3",
",",
"0",
")",
")",
":",
"if",
"isinstance",
"(",
"coro",
",",
"GeneratorType",
")",
":",
"return",
"_inlineCallbacks",
"(",
"None",
",",
"coro",
",",
"Deferred",
"(",
")",
")",
"if",
"(",
"not",
"isinstance",
"(",
"coro",
",",
"Deferred",
")",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'%r is not a coroutine or a Deferred'",
"%",
"(",
"coro",
",",
")",
")",
")",
"return",
"coro"
] |
schedule the execution of a coroutine that awaits/yields from l{deferred}s .
|
train
| false
|
8,352
|
def _trim_id(data):
old_id = data['id']
del data['id']
return (old_id, data)
|
[
"def",
"_trim_id",
"(",
"data",
")",
":",
"old_id",
"=",
"data",
"[",
"'id'",
"]",
"del",
"data",
"[",
"'id'",
"]",
"return",
"(",
"old_id",
",",
"data",
")"
] |
trims id from json .
|
train
| false
|
8,353
|
def get_s3a_access_key():
return get_conf().get(_CNF_S3A_ACCESS_KEY)
|
[
"def",
"get_s3a_access_key",
"(",
")",
":",
"return",
"get_conf",
"(",
")",
".",
"get",
"(",
"_CNF_S3A_ACCESS_KEY",
")"
] |
get s3a aws access key id URL .
|
train
| false
|
8,355
|
def axapi_call(module, url, post=None):
(rsp, info) = fetch_url(module, url, data=post)
if ((not rsp) or (info['status'] >= 400)):
module.fail_json(msg=('failed to connect (status code %s), error was %s' % (info['status'], info.get('msg', 'no error given'))))
try:
raw_data = rsp.read()
data = json.loads(raw_data)
except ValueError:
if ('status="ok"' in raw_data.lower()):
data = {'response': {'status': 'OK'}}
else:
data = {'response': {'status': 'fail', 'err': {'msg': raw_data}}}
except:
module.fail_json(msg='could not read the result from the host')
finally:
rsp.close()
return data
|
[
"def",
"axapi_call",
"(",
"module",
",",
"url",
",",
"post",
"=",
"None",
")",
":",
"(",
"rsp",
",",
"info",
")",
"=",
"fetch_url",
"(",
"module",
",",
"url",
",",
"data",
"=",
"post",
")",
"if",
"(",
"(",
"not",
"rsp",
")",
"or",
"(",
"info",
"[",
"'status'",
"]",
">=",
"400",
")",
")",
":",
"module",
".",
"fail_json",
"(",
"msg",
"=",
"(",
"'failed to connect (status code %s), error was %s'",
"%",
"(",
"info",
"[",
"'status'",
"]",
",",
"info",
".",
"get",
"(",
"'msg'",
",",
"'no error given'",
")",
")",
")",
")",
"try",
":",
"raw_data",
"=",
"rsp",
".",
"read",
"(",
")",
"data",
"=",
"json",
".",
"loads",
"(",
"raw_data",
")",
"except",
"ValueError",
":",
"if",
"(",
"'status=\"ok\"'",
"in",
"raw_data",
".",
"lower",
"(",
")",
")",
":",
"data",
"=",
"{",
"'response'",
":",
"{",
"'status'",
":",
"'OK'",
"}",
"}",
"else",
":",
"data",
"=",
"{",
"'response'",
":",
"{",
"'status'",
":",
"'fail'",
",",
"'err'",
":",
"{",
"'msg'",
":",
"raw_data",
"}",
"}",
"}",
"except",
":",
"module",
".",
"fail_json",
"(",
"msg",
"=",
"'could not read the result from the host'",
")",
"finally",
":",
"rsp",
".",
"close",
"(",
")",
"return",
"data"
] |
returns a datastructure based on the result of the api call .
|
train
| false
|
8,356
|
def _ensure_llvm():
import warnings
import llvmlite
regex = re.compile('(\\d+)\\.(\\d+).(\\d+)')
m = regex.match(llvmlite.__version__)
if m:
ver = tuple(map(int, m.groups()))
if (ver < _min_llvmlite_version):
msg = ('Numba requires at least version %d.%d.%d of llvmlite.\nInstalled version is %s.\nPlease update llvmlite.' % (_min_llvmlite_version + (llvmlite.__version__,)))
raise ImportError(msg)
else:
warnings.warn('llvmlite version format not recognized!')
from llvmlite.binding import llvm_version_info, check_jit_execution
if (llvm_version_info < _min_llvm_version):
msg = ('Numba requires at least version %d.%d.%d of LLVM.\nInstalled llvmlite is built against version %d.%d.%d.\nPlease update llvmlite.' % (_min_llvm_version + llvm_version_info))
raise ImportError(msg)
check_jit_execution()
|
[
"def",
"_ensure_llvm",
"(",
")",
":",
"import",
"warnings",
"import",
"llvmlite",
"regex",
"=",
"re",
".",
"compile",
"(",
"'(\\\\d+)\\\\.(\\\\d+).(\\\\d+)'",
")",
"m",
"=",
"regex",
".",
"match",
"(",
"llvmlite",
".",
"__version__",
")",
"if",
"m",
":",
"ver",
"=",
"tuple",
"(",
"map",
"(",
"int",
",",
"m",
".",
"groups",
"(",
")",
")",
")",
"if",
"(",
"ver",
"<",
"_min_llvmlite_version",
")",
":",
"msg",
"=",
"(",
"'Numba requires at least version %d.%d.%d of llvmlite.\\nInstalled version is %s.\\nPlease update llvmlite.'",
"%",
"(",
"_min_llvmlite_version",
"+",
"(",
"llvmlite",
".",
"__version__",
",",
")",
")",
")",
"raise",
"ImportError",
"(",
"msg",
")",
"else",
":",
"warnings",
".",
"warn",
"(",
"'llvmlite version format not recognized!'",
")",
"from",
"llvmlite",
".",
"binding",
"import",
"llvm_version_info",
",",
"check_jit_execution",
"if",
"(",
"llvm_version_info",
"<",
"_min_llvm_version",
")",
":",
"msg",
"=",
"(",
"'Numba requires at least version %d.%d.%d of LLVM.\\nInstalled llvmlite is built against version %d.%d.%d.\\nPlease update llvmlite.'",
"%",
"(",
"_min_llvm_version",
"+",
"llvm_version_info",
")",
")",
"raise",
"ImportError",
"(",
"msg",
")",
"check_jit_execution",
"(",
")"
] |
make sure llvmlite is operational .
|
train
| false
|
8,357
|
def _xor_bytes(aggregating_bytearray, updating_bytes):
for i in xrange(len(aggregating_bytearray)):
aggregating_bytearray[i] ^= ord(updating_bytes[i])
return aggregating_bytearray
|
[
"def",
"_xor_bytes",
"(",
"aggregating_bytearray",
",",
"updating_bytes",
")",
":",
"for",
"i",
"in",
"xrange",
"(",
"len",
"(",
"aggregating_bytearray",
")",
")",
":",
"aggregating_bytearray",
"[",
"i",
"]",
"^=",
"ord",
"(",
"updating_bytes",
"[",
"i",
"]",
")",
"return",
"aggregating_bytearray"
] |
aggregate bytes into a bytearray using xor .
|
train
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.