id_within_dataset
int64 1
55.5k
| snippet
stringlengths 19
14.2k
| tokens
listlengths 6
1.63k
| nl
stringlengths 6
352
| split_within_dataset
stringclasses 1
value | is_duplicated
bool 2
classes |
|---|---|---|---|---|---|
13,529
|
def isRat(x):
return isinstance(x, Rat)
|
[
"def",
"isRat",
"(",
"x",
")",
":",
"return",
"isinstance",
"(",
"x",
",",
"Rat",
")"
] |
test wheter an object is an instance of the rat class .
|
train
| false
|
13,531
|
@register.function
@jinja2.contextfunction
def hub_breadcrumbs(context, addon=None, items=None, add_default=False):
crumbs = [(reverse('ecosystem.landing'), _('Developers'))]
title = _('My Submissions')
link = reverse('mkt.developers.apps')
if addon:
if ((not addon) and (not items)):
crumbs.append((None, title))
else:
crumbs.append((link, title))
if items:
url = addon.get_dev_url()
else:
url = None
crumbs.append((url, addon.name))
if items:
crumbs.extend(items)
if (len(crumbs) == 1):
crumbs = []
return mkt_breadcrumbs(context, items=crumbs)
|
[
"@",
"register",
".",
"function",
"@",
"jinja2",
".",
"contextfunction",
"def",
"hub_breadcrumbs",
"(",
"context",
",",
"addon",
"=",
"None",
",",
"items",
"=",
"None",
",",
"add_default",
"=",
"False",
")",
":",
"crumbs",
"=",
"[",
"(",
"reverse",
"(",
"'ecosystem.landing'",
")",
",",
"_",
"(",
"'Developers'",
")",
")",
"]",
"title",
"=",
"_",
"(",
"'My Submissions'",
")",
"link",
"=",
"reverse",
"(",
"'mkt.developers.apps'",
")",
"if",
"addon",
":",
"if",
"(",
"(",
"not",
"addon",
")",
"and",
"(",
"not",
"items",
")",
")",
":",
"crumbs",
".",
"append",
"(",
"(",
"None",
",",
"title",
")",
")",
"else",
":",
"crumbs",
".",
"append",
"(",
"(",
"link",
",",
"title",
")",
")",
"if",
"items",
":",
"url",
"=",
"addon",
".",
"get_dev_url",
"(",
")",
"else",
":",
"url",
"=",
"None",
"crumbs",
".",
"append",
"(",
"(",
"url",
",",
"addon",
".",
"name",
")",
")",
"if",
"items",
":",
"crumbs",
".",
"extend",
"(",
"items",
")",
"if",
"(",
"len",
"(",
"crumbs",
")",
"==",
"1",
")",
":",
"crumbs",
"=",
"[",
"]",
"return",
"mkt_breadcrumbs",
"(",
"context",
",",
"items",
"=",
"crumbs",
")"
] |
wrapper function for breadcrumbs .
|
train
| false
|
13,532
|
def readWriteDeleteHypertextHelp(documentDirectoryPath, hypertextFileIndex, hypertextFiles, transferredFileNames):
fileName = os.path.basename(hypertextFiles[hypertextFileIndex])
print ('readWriteDeleteHypertextHelp ' + fileName)
filePath = os.path.join(documentDirectoryPath, fileName)
fileText = archive.getFileText(fileName)
fileText = getWrappedHypertext(fileText, hypertextFileIndex, hypertextFiles)
if (fileText.find('This page is in the table of contents.') > (-1)):
fileText = fileText.replace('This page is in the table of contents.', '')
transferredFileNames.append(fileName)
archive.writeFileText(filePath, fileText)
os.remove(fileName)
|
[
"def",
"readWriteDeleteHypertextHelp",
"(",
"documentDirectoryPath",
",",
"hypertextFileIndex",
",",
"hypertextFiles",
",",
"transferredFileNames",
")",
":",
"fileName",
"=",
"os",
".",
"path",
".",
"basename",
"(",
"hypertextFiles",
"[",
"hypertextFileIndex",
"]",
")",
"print",
"(",
"'readWriteDeleteHypertextHelp '",
"+",
"fileName",
")",
"filePath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"documentDirectoryPath",
",",
"fileName",
")",
"fileText",
"=",
"archive",
".",
"getFileText",
"(",
"fileName",
")",
"fileText",
"=",
"getWrappedHypertext",
"(",
"fileText",
",",
"hypertextFileIndex",
",",
"hypertextFiles",
")",
"if",
"(",
"fileText",
".",
"find",
"(",
"'This page is in the table of contents.'",
")",
">",
"(",
"-",
"1",
")",
")",
":",
"fileText",
"=",
"fileText",
".",
"replace",
"(",
"'This page is in the table of contents.'",
",",
"''",
")",
"transferredFileNames",
".",
"append",
"(",
"fileName",
")",
"archive",
".",
"writeFileText",
"(",
"filePath",
",",
"fileText",
")",
"os",
".",
"remove",
"(",
"fileName",
")"
] |
read the pydoc hypertext help documents .
|
train
| false
|
13,534
|
def _a_encode_none(value, mapping):
return ['0n']
|
[
"def",
"_a_encode_none",
"(",
"value",
",",
"mapping",
")",
":",
"return",
"[",
"'0n'",
"]"
] |
none --> [0 .
|
train
| false
|
13,535
|
def get_cxxflags():
return get_var('CXXFLAGS')
|
[
"def",
"get_cxxflags",
"(",
")",
":",
"return",
"get_var",
"(",
"'CXXFLAGS'",
")"
] |
get the value of cxxflags variable in the make .
|
train
| false
|
13,536
|
def getPointsFromLoop(loop, radius, thresholdRatio=0.9):
radius = abs(radius)
points = []
for pointIndex in xrange(len(loop)):
pointBegin = loop[pointIndex]
pointEnd = loop[((pointIndex + 1) % len(loop))]
points.append(pointBegin)
addPointsFromSegment(pointBegin, pointEnd, points, radius, thresholdRatio)
return points
|
[
"def",
"getPointsFromLoop",
"(",
"loop",
",",
"radius",
",",
"thresholdRatio",
"=",
"0.9",
")",
":",
"radius",
"=",
"abs",
"(",
"radius",
")",
"points",
"=",
"[",
"]",
"for",
"pointIndex",
"in",
"xrange",
"(",
"len",
"(",
"loop",
")",
")",
":",
"pointBegin",
"=",
"loop",
"[",
"pointIndex",
"]",
"pointEnd",
"=",
"loop",
"[",
"(",
"(",
"pointIndex",
"+",
"1",
")",
"%",
"len",
"(",
"loop",
")",
")",
"]",
"points",
".",
"append",
"(",
"pointBegin",
")",
"addPointsFromSegment",
"(",
"pointBegin",
",",
"pointEnd",
",",
"points",
",",
"radius",
",",
"thresholdRatio",
")",
"return",
"points"
] |
get the points from every point on a loop and between points .
|
train
| false
|
13,540
|
def extract_variables(log_format):
if (log_format == 'combined'):
log_format = LOG_FORMAT_COMBINED
for match in re.findall(REGEX_LOG_FORMAT_VARIABLE, log_format):
(yield match)
|
[
"def",
"extract_variables",
"(",
"log_format",
")",
":",
"if",
"(",
"log_format",
"==",
"'combined'",
")",
":",
"log_format",
"=",
"LOG_FORMAT_COMBINED",
"for",
"match",
"in",
"re",
".",
"findall",
"(",
"REGEX_LOG_FORMAT_VARIABLE",
",",
"log_format",
")",
":",
"(",
"yield",
"match",
")"
] |
extract all variables from a log format string .
|
train
| true
|
13,541
|
def handleEventException(source, event, args, kw, exc_info):
try:
c = source
t = event
if hasattr(c, '__class__'):
c = c.__class__.__name__
if isinstance(t, Event):
t = t.__class__.__name__
elif issubclass(t, Event):
t = t.__name__
except:
pass
import sys
sys.stderr.write(('Exception while handling %s!%s...\n' % (c, t)))
import traceback
traceback.print_exception(*exc_info)
|
[
"def",
"handleEventException",
"(",
"source",
",",
"event",
",",
"args",
",",
"kw",
",",
"exc_info",
")",
":",
"try",
":",
"c",
"=",
"source",
"t",
"=",
"event",
"if",
"hasattr",
"(",
"c",
",",
"'__class__'",
")",
":",
"c",
"=",
"c",
".",
"__class__",
".",
"__name__",
"if",
"isinstance",
"(",
"t",
",",
"Event",
")",
":",
"t",
"=",
"t",
".",
"__class__",
".",
"__name__",
"elif",
"issubclass",
"(",
"t",
",",
"Event",
")",
":",
"t",
"=",
"t",
".",
"__name__",
"except",
":",
"pass",
"import",
"sys",
"sys",
".",
"stderr",
".",
"write",
"(",
"(",
"'Exception while handling %s!%s...\\n'",
"%",
"(",
"c",
",",
"t",
")",
")",
")",
"import",
"traceback",
"traceback",
".",
"print_exception",
"(",
"*",
"exc_info",
")"
] |
called when an exception is raised by an event handler when the event was raised by raiseeventnoerrors() .
|
train
| false
|
13,542
|
def _do_mb_query(entity, id, includes=[], params={}):
if (not isinstance(includes, list)):
includes = [includes]
_check_includes(entity, includes)
auth_required = _get_auth_type(entity, id, includes)
args = dict(params)
if (len(includes) > 0):
inc = ' '.join(includes)
args['inc'] = inc
path = ('%s/%s' % (entity, id))
return _mb_request(path, 'GET', auth_required, args=args)
|
[
"def",
"_do_mb_query",
"(",
"entity",
",",
"id",
",",
"includes",
"=",
"[",
"]",
",",
"params",
"=",
"{",
"}",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"includes",
",",
"list",
")",
")",
":",
"includes",
"=",
"[",
"includes",
"]",
"_check_includes",
"(",
"entity",
",",
"includes",
")",
"auth_required",
"=",
"_get_auth_type",
"(",
"entity",
",",
"id",
",",
"includes",
")",
"args",
"=",
"dict",
"(",
"params",
")",
"if",
"(",
"len",
"(",
"includes",
")",
">",
"0",
")",
":",
"inc",
"=",
"' '",
".",
"join",
"(",
"includes",
")",
"args",
"[",
"'inc'",
"]",
"=",
"inc",
"path",
"=",
"(",
"'%s/%s'",
"%",
"(",
"entity",
",",
"id",
")",
")",
"return",
"_mb_request",
"(",
"path",
",",
"'GET'",
",",
"auth_required",
",",
"args",
"=",
"args",
")"
] |
make a single get call to the musicbrainz xml api .
|
train
| false
|
13,543
|
def new_create_tag(name=u'', ref=u'', sign=False, settings=None, parent=None):
opts = TagOptions(name, ref, sign)
view = CreateTag(opts, settings=settings, parent=parent)
return view
|
[
"def",
"new_create_tag",
"(",
"name",
"=",
"u''",
",",
"ref",
"=",
"u''",
",",
"sign",
"=",
"False",
",",
"settings",
"=",
"None",
",",
"parent",
"=",
"None",
")",
":",
"opts",
"=",
"TagOptions",
"(",
"name",
",",
"ref",
",",
"sign",
")",
"view",
"=",
"CreateTag",
"(",
"opts",
",",
"settings",
"=",
"settings",
",",
"parent",
"=",
"parent",
")",
"return",
"view"
] |
entry point for external callers .
|
train
| false
|
13,544
|
def prints(*args, **kwargs):
file = kwargs.get('file', sys.stdout)
sep = kwargs.get('sep', ' ')
end = kwargs.get('end', '\n')
enc = preferred_encoding
safe_encode = kwargs.get('safe_encode', False)
if ('CALIBRE_WORKER' in os.environ):
enc = 'utf-8'
for (i, arg) in enumerate(args):
if isinstance(arg, unicode):
try:
arg = arg.encode(enc)
except UnicodeEncodeError:
try:
arg = arg.encode('utf-8')
except:
if (not safe_encode):
raise
arg = repr(arg)
if (not isinstance(arg, str)):
try:
arg = str(arg)
except ValueError:
arg = unicode(arg)
if isinstance(arg, unicode):
try:
arg = arg.encode(enc)
except UnicodeEncodeError:
try:
arg = arg.encode('utf-8')
except:
if (not safe_encode):
raise
arg = repr(arg)
try:
file.write(arg)
except:
import repr as reprlib
file.write(reprlib.repr(arg))
if (i != (len(args) - 1)):
file.write(bytes(sep))
file.write(bytes(end))
|
[
"def",
"prints",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"file",
"=",
"kwargs",
".",
"get",
"(",
"'file'",
",",
"sys",
".",
"stdout",
")",
"sep",
"=",
"kwargs",
".",
"get",
"(",
"'sep'",
",",
"' '",
")",
"end",
"=",
"kwargs",
".",
"get",
"(",
"'end'",
",",
"'\\n'",
")",
"enc",
"=",
"preferred_encoding",
"safe_encode",
"=",
"kwargs",
".",
"get",
"(",
"'safe_encode'",
",",
"False",
")",
"if",
"(",
"'CALIBRE_WORKER'",
"in",
"os",
".",
"environ",
")",
":",
"enc",
"=",
"'utf-8'",
"for",
"(",
"i",
",",
"arg",
")",
"in",
"enumerate",
"(",
"args",
")",
":",
"if",
"isinstance",
"(",
"arg",
",",
"unicode",
")",
":",
"try",
":",
"arg",
"=",
"arg",
".",
"encode",
"(",
"enc",
")",
"except",
"UnicodeEncodeError",
":",
"try",
":",
"arg",
"=",
"arg",
".",
"encode",
"(",
"'utf-8'",
")",
"except",
":",
"if",
"(",
"not",
"safe_encode",
")",
":",
"raise",
"arg",
"=",
"repr",
"(",
"arg",
")",
"if",
"(",
"not",
"isinstance",
"(",
"arg",
",",
"str",
")",
")",
":",
"try",
":",
"arg",
"=",
"str",
"(",
"arg",
")",
"except",
"ValueError",
":",
"arg",
"=",
"unicode",
"(",
"arg",
")",
"if",
"isinstance",
"(",
"arg",
",",
"unicode",
")",
":",
"try",
":",
"arg",
"=",
"arg",
".",
"encode",
"(",
"enc",
")",
"except",
"UnicodeEncodeError",
":",
"try",
":",
"arg",
"=",
"arg",
".",
"encode",
"(",
"'utf-8'",
")",
"except",
":",
"if",
"(",
"not",
"safe_encode",
")",
":",
"raise",
"arg",
"=",
"repr",
"(",
"arg",
")",
"try",
":",
"file",
".",
"write",
"(",
"arg",
")",
"except",
":",
"import",
"repr",
"as",
"reprlib",
"file",
".",
"write",
"(",
"reprlib",
".",
"repr",
"(",
"arg",
")",
")",
"if",
"(",
"i",
"!=",
"(",
"len",
"(",
"args",
")",
"-",
"1",
")",
")",
":",
"file",
".",
"write",
"(",
"bytes",
"(",
"sep",
")",
")",
"file",
".",
"write",
"(",
"bytes",
"(",
"end",
")",
")"
] |
print unicode arguments safely by encoding them to preferred_encoding has the same signature as the print function from python 3 .
|
train
| false
|
13,545
|
def print_title(text):
print_col('==================== {} ===================='.format(text), 'yellow')
|
[
"def",
"print_title",
"(",
"text",
")",
":",
"print_col",
"(",
"'==================== {} ===================='",
".",
"format",
"(",
"text",
")",
",",
"'yellow'",
")"
] |
print a title .
|
train
| false
|
13,546
|
def channel_data_files(dest=None):
channel_data_filename = 'channel_data.json'
if dest:
if (not channel_data_path):
sourcedir = os.path.dirname(path)
sourcefile = ((os.path.basename(path) + '.json') if os.path.exists((os.path.basename(path) + '.json')) else channel_data_filename)
else:
sourcedir = channel_data_path
sourcefile = channel_data_filename
shutil.copy(os.path.join(sourcedir, sourcefile), os.path.join(dest, channel_data_filename))
shutil.rmtree(os.path.join(dest, 'images'), ignore_errors=True)
shutil.copytree(os.path.join(sourcedir, 'images'), os.path.join(dest, 'images'))
|
[
"def",
"channel_data_files",
"(",
"dest",
"=",
"None",
")",
":",
"channel_data_filename",
"=",
"'channel_data.json'",
"if",
"dest",
":",
"if",
"(",
"not",
"channel_data_path",
")",
":",
"sourcedir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"path",
")",
"sourcefile",
"=",
"(",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"path",
")",
"+",
"'.json'",
")",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"(",
"os",
".",
"path",
".",
"basename",
"(",
"path",
")",
"+",
"'.json'",
")",
")",
"else",
"channel_data_filename",
")",
"else",
":",
"sourcedir",
"=",
"channel_data_path",
"sourcefile",
"=",
"channel_data_filename",
"shutil",
".",
"copy",
"(",
"os",
".",
"path",
".",
"join",
"(",
"sourcedir",
",",
"sourcefile",
")",
",",
"os",
".",
"path",
".",
"join",
"(",
"dest",
",",
"channel_data_filename",
")",
")",
"shutil",
".",
"rmtree",
"(",
"os",
".",
"path",
".",
"join",
"(",
"dest",
",",
"'images'",
")",
",",
"ignore_errors",
"=",
"True",
")",
"shutil",
".",
"copytree",
"(",
"os",
".",
"path",
".",
"join",
"(",
"sourcedir",
",",
"'images'",
")",
",",
"os",
".",
"path",
".",
"join",
"(",
"dest",
",",
"'images'",
")",
")"
] |
copies all remaining files to appropriate channel data directory .
|
train
| false
|
13,547
|
def session_view(request):
request.session['tobacconist'] = 'hovercraft'
t = Template('This is a view that modifies the session.', name='Session Modifying View Template')
c = Context()
return HttpResponse(t.render(c))
|
[
"def",
"session_view",
"(",
"request",
")",
":",
"request",
".",
"session",
"[",
"'tobacconist'",
"]",
"=",
"'hovercraft'",
"t",
"=",
"Template",
"(",
"'This is a view that modifies the session.'",
",",
"name",
"=",
"'Session Modifying View Template'",
")",
"c",
"=",
"Context",
"(",
")",
"return",
"HttpResponse",
"(",
"t",
".",
"render",
"(",
"c",
")",
")"
] |
a view that modifies the session .
|
train
| false
|
13,548
|
def get_job_output(job_id):
return job_models.JobModel.get_by_id(job_id).output
|
[
"def",
"get_job_output",
"(",
"job_id",
")",
":",
"return",
"job_models",
".",
"JobModel",
".",
"get_by_id",
"(",
"job_id",
")",
".",
"output"
] |
returns the output of a job .
|
train
| false
|
13,549
|
def nearlyEqual(lst1, lst2, tolerance=0.001):
return all(((abs((i - j)) <= tolerance) for (i, j) in zip(lst1, lst2)))
|
[
"def",
"nearlyEqual",
"(",
"lst1",
",",
"lst2",
",",
"tolerance",
"=",
"0.001",
")",
":",
"return",
"all",
"(",
"(",
"(",
"abs",
"(",
"(",
"i",
"-",
"j",
")",
")",
"<=",
"tolerance",
")",
"for",
"(",
"i",
",",
"j",
")",
"in",
"zip",
"(",
"lst1",
",",
"lst2",
")",
")",
")"
] |
tell whether the itemwise differences of the two lists is never bigger than tolerance .
|
train
| false
|
13,550
|
def get_latest_versions(versions, num=1):
versions = group_versions(versions)
return [versions[index][0] for index in range(num)]
|
[
"def",
"get_latest_versions",
"(",
"versions",
",",
"num",
"=",
"1",
")",
":",
"versions",
"=",
"group_versions",
"(",
"versions",
")",
"return",
"[",
"versions",
"[",
"index",
"]",
"[",
"0",
"]",
"for",
"index",
"in",
"range",
"(",
"num",
")",
"]"
] |
return a list of the most recent versions for each major .
|
train
| false
|
13,551
|
def are_content_experiments_enabled(course):
return (('split_test' in ADVANCED_COMPONENT_TYPES) and ('split_test' in course.advanced_modules))
|
[
"def",
"are_content_experiments_enabled",
"(",
"course",
")",
":",
"return",
"(",
"(",
"'split_test'",
"in",
"ADVANCED_COMPONENT_TYPES",
")",
"and",
"(",
"'split_test'",
"in",
"course",
".",
"advanced_modules",
")",
")"
] |
returns true if content experiments have been enabled for the course .
|
train
| false
|
13,553
|
def beta_from_features(dataset, **kwargs):
return beta_from_design(dataset.X, **kwargs)
|
[
"def",
"beta_from_features",
"(",
"dataset",
",",
"**",
"kwargs",
")",
":",
"return",
"beta_from_design",
"(",
"dataset",
".",
"X",
",",
"**",
"kwargs",
")"
] |
returns the marginal precision of the features in a dataset .
|
train
| false
|
13,554
|
def basic_clean_up_f(f):
deletion_list = [l.strip() for l in f]
remove_all(deletion_list)
return True
|
[
"def",
"basic_clean_up_f",
"(",
"f",
")",
":",
"deletion_list",
"=",
"[",
"l",
".",
"strip",
"(",
")",
"for",
"l",
"in",
"f",
"]",
"remove_all",
"(",
"deletion_list",
")",
"return",
"True"
] |
removes list of files in f f: file containing list of filepaths example f: f1 .
|
train
| false
|
13,555
|
def generate_open_shard_key():
open_shards = get_open_shards()
shard_id = random.choice(open_shards)
key = (shard_id << 48)
return key
|
[
"def",
"generate_open_shard_key",
"(",
")",
":",
"open_shards",
"=",
"get_open_shards",
"(",
")",
"shard_id",
"=",
"random",
".",
"choice",
"(",
"open_shards",
")",
"key",
"=",
"(",
"shard_id",
"<<",
"48",
")",
"return",
"key"
] |
return the key that can be passed into session_scope() for an open shard .
|
train
| false
|
13,556
|
def GetCurrentTimestamp():
return (_TEST_TIME if (_TEST_TIME is not None) else time.time())
|
[
"def",
"GetCurrentTimestamp",
"(",
")",
":",
"return",
"(",
"_TEST_TIME",
"if",
"(",
"_TEST_TIME",
"is",
"not",
"None",
")",
"else",
"time",
".",
"time",
"(",
")",
")"
] |
if _test_time has been set .
|
train
| false
|
13,557
|
@command('fileset', optional=['filename'])
def fileset_command(options, input_filename=None):
with open_input_file(input_filename) as input_file:
descriptor_content = input_file.read()
dest_dir = os.path.expanduser(options.dest_dir)
if ((not os.path.isdir(dest_dir)) and os.path.exists(dest_dir)):
fatal_error(("Destination '%s' is not a directory" % dest_dir))
file_set = protobuf.decode_message(descriptor.FileSet, descriptor_content)
for file_descriptor in file_set.files:
generate_file_descriptor(dest_dir, file_descriptor=file_descriptor, force_overwrite=options.force)
|
[
"@",
"command",
"(",
"'fileset'",
",",
"optional",
"=",
"[",
"'filename'",
"]",
")",
"def",
"fileset_command",
"(",
"options",
",",
"input_filename",
"=",
"None",
")",
":",
"with",
"open_input_file",
"(",
"input_filename",
")",
"as",
"input_file",
":",
"descriptor_content",
"=",
"input_file",
".",
"read",
"(",
")",
"dest_dir",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"options",
".",
"dest_dir",
")",
"if",
"(",
"(",
"not",
"os",
".",
"path",
".",
"isdir",
"(",
"dest_dir",
")",
")",
"and",
"os",
".",
"path",
".",
"exists",
"(",
"dest_dir",
")",
")",
":",
"fatal_error",
"(",
"(",
"\"Destination '%s' is not a directory\"",
"%",
"dest_dir",
")",
")",
"file_set",
"=",
"protobuf",
".",
"decode_message",
"(",
"descriptor",
".",
"FileSet",
",",
"descriptor_content",
")",
"for",
"file_descriptor",
"in",
"file_set",
".",
"files",
":",
"generate_file_descriptor",
"(",
"dest_dir",
",",
"file_descriptor",
"=",
"file_descriptor",
",",
"force_overwrite",
"=",
"options",
".",
"force",
")"
] |
generate source directory structure from fileset .
|
train
| false
|
13,558
|
def random_urlsafe_str():
return base64.urlsafe_b64encode(uuid.uuid4().bytes)[:(-2)].decode('utf-8')
|
[
"def",
"random_urlsafe_str",
"(",
")",
":",
"return",
"base64",
".",
"urlsafe_b64encode",
"(",
"uuid",
".",
"uuid4",
"(",
")",
".",
"bytes",
")",
"[",
":",
"(",
"-",
"2",
")",
"]",
".",
"decode",
"(",
"'utf-8'",
")"
] |
generate a random url-safe string .
|
train
| false
|
13,559
|
def test_Trapezoid1D():
model = models.Trapezoid1D(amplitude=4.2, x_0=2.0, width=1.0, slope=3)
xx = np.linspace(0, 4, 8)
yy = model(xx)
yy_ref = [0.0, 1.41428571, 3.12857143, 4.2, 4.2, 3.12857143, 1.41428571, 0.0]
assert_allclose(yy, yy_ref, rtol=0, atol=1e-06)
|
[
"def",
"test_Trapezoid1D",
"(",
")",
":",
"model",
"=",
"models",
".",
"Trapezoid1D",
"(",
"amplitude",
"=",
"4.2",
",",
"x_0",
"=",
"2.0",
",",
"width",
"=",
"1.0",
",",
"slope",
"=",
"3",
")",
"xx",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"4",
",",
"8",
")",
"yy",
"=",
"model",
"(",
"xx",
")",
"yy_ref",
"=",
"[",
"0.0",
",",
"1.41428571",
",",
"3.12857143",
",",
"4.2",
",",
"4.2",
",",
"3.12857143",
",",
"1.41428571",
",",
"0.0",
"]",
"assert_allclose",
"(",
"yy",
",",
"yy_ref",
",",
"rtol",
"=",
"0",
",",
"atol",
"=",
"1e-06",
")"
] |
regression test for URL .
|
train
| false
|
13,560
|
def handle_shared_float32(tf):
if tf:
theano.compile.shared_constructor(float32_shared_constructor)
else:
theano.compile.shared_constructor(float32_shared_constructor, True)
assert (float32_shared_constructor not in theano.compile.shared.constructors)
|
[
"def",
"handle_shared_float32",
"(",
"tf",
")",
":",
"if",
"tf",
":",
"theano",
".",
"compile",
".",
"shared_constructor",
"(",
"float32_shared_constructor",
")",
"else",
":",
"theano",
".",
"compile",
".",
"shared_constructor",
"(",
"float32_shared_constructor",
",",
"True",
")",
"assert",
"(",
"float32_shared_constructor",
"not",
"in",
"theano",
".",
"compile",
".",
"shared",
".",
"constructors",
")"
] |
set the default shared type for float32 tensor to cudandarraytype .
|
train
| false
|
13,561
|
def _acquire_subtask_lock(task_id):
key = 'subtask-{}'.format(task_id)
succeeded = cache.add(key, 'true', SUBTASK_LOCK_EXPIRE)
if (not succeeded):
TASK_LOG.warning("task_id '%s': already locked. Contains value '%s'", task_id, cache.get(key))
return succeeded
|
[
"def",
"_acquire_subtask_lock",
"(",
"task_id",
")",
":",
"key",
"=",
"'subtask-{}'",
".",
"format",
"(",
"task_id",
")",
"succeeded",
"=",
"cache",
".",
"add",
"(",
"key",
",",
"'true'",
",",
"SUBTASK_LOCK_EXPIRE",
")",
"if",
"(",
"not",
"succeeded",
")",
":",
"TASK_LOG",
".",
"warning",
"(",
"\"task_id '%s': already locked. Contains value '%s'\"",
",",
"task_id",
",",
"cache",
".",
"get",
"(",
"key",
")",
")",
"return",
"succeeded"
] |
mark the specified task_id as being in progress .
|
train
| false
|
13,562
|
def http_log_req(method, uri, args, kwargs):
if (not pyrax.get_http_debug()):
return
string_parts = [('curl -i -X %s' % method)]
for element in args:
string_parts.append(('%s' % element))
for element in kwargs['headers']:
header = ("-H '%s: %s'" % (element, kwargs['headers'][element]))
string_parts.append(header)
string_parts.append(uri)
log = logging.getLogger('pyrax')
log.debug(('\nREQ: %s\n' % ' '.join(string_parts)))
if ('body' in kwargs):
pyrax._logger.debug(('REQ BODY: %s\n' % kwargs['body']))
if ('data' in kwargs):
pyrax._logger.debug(('REQ DATA: %s\n' % kwargs['data']))
|
[
"def",
"http_log_req",
"(",
"method",
",",
"uri",
",",
"args",
",",
"kwargs",
")",
":",
"if",
"(",
"not",
"pyrax",
".",
"get_http_debug",
"(",
")",
")",
":",
"return",
"string_parts",
"=",
"[",
"(",
"'curl -i -X %s'",
"%",
"method",
")",
"]",
"for",
"element",
"in",
"args",
":",
"string_parts",
".",
"append",
"(",
"(",
"'%s'",
"%",
"element",
")",
")",
"for",
"element",
"in",
"kwargs",
"[",
"'headers'",
"]",
":",
"header",
"=",
"(",
"\"-H '%s: %s'\"",
"%",
"(",
"element",
",",
"kwargs",
"[",
"'headers'",
"]",
"[",
"element",
"]",
")",
")",
"string_parts",
".",
"append",
"(",
"header",
")",
"string_parts",
".",
"append",
"(",
"uri",
")",
"log",
"=",
"logging",
".",
"getLogger",
"(",
"'pyrax'",
")",
"log",
".",
"debug",
"(",
"(",
"'\\nREQ: %s\\n'",
"%",
"' '",
".",
"join",
"(",
"string_parts",
")",
")",
")",
"if",
"(",
"'body'",
"in",
"kwargs",
")",
":",
"pyrax",
".",
"_logger",
".",
"debug",
"(",
"(",
"'REQ BODY: %s\\n'",
"%",
"kwargs",
"[",
"'body'",
"]",
")",
")",
"if",
"(",
"'data'",
"in",
"kwargs",
")",
":",
"pyrax",
".",
"_logger",
".",
"debug",
"(",
"(",
"'REQ DATA: %s\\n'",
"%",
"kwargs",
"[",
"'data'",
"]",
")",
")"
] |
when pyrax .
|
train
| true
|
13,563
|
def dmp_zz_wang_test_points(f, T, ct, A, u, K):
if (not dmp_eval_tail(dmp_LC(f, K), A, (u - 1), K)):
raise EvaluationFailed('no luck')
g = dmp_eval_tail(f, A, u, K)
if (not dup_sqf_p(g, K)):
raise EvaluationFailed('no luck')
(c, h) = dup_primitive(g, K)
if K.is_negative(dup_LC(h, K)):
(c, h) = ((- c), dup_neg(h, K))
v = (u - 1)
E = [dmp_eval_tail(t, A, v, K) for (t, _) in T]
D = dmp_zz_wang_non_divisors(E, c, ct, K)
if (D is not None):
return (c, h, E)
else:
raise EvaluationFailed('no luck')
|
[
"def",
"dmp_zz_wang_test_points",
"(",
"f",
",",
"T",
",",
"ct",
",",
"A",
",",
"u",
",",
"K",
")",
":",
"if",
"(",
"not",
"dmp_eval_tail",
"(",
"dmp_LC",
"(",
"f",
",",
"K",
")",
",",
"A",
",",
"(",
"u",
"-",
"1",
")",
",",
"K",
")",
")",
":",
"raise",
"EvaluationFailed",
"(",
"'no luck'",
")",
"g",
"=",
"dmp_eval_tail",
"(",
"f",
",",
"A",
",",
"u",
",",
"K",
")",
"if",
"(",
"not",
"dup_sqf_p",
"(",
"g",
",",
"K",
")",
")",
":",
"raise",
"EvaluationFailed",
"(",
"'no luck'",
")",
"(",
"c",
",",
"h",
")",
"=",
"dup_primitive",
"(",
"g",
",",
"K",
")",
"if",
"K",
".",
"is_negative",
"(",
"dup_LC",
"(",
"h",
",",
"K",
")",
")",
":",
"(",
"c",
",",
"h",
")",
"=",
"(",
"(",
"-",
"c",
")",
",",
"dup_neg",
"(",
"h",
",",
"K",
")",
")",
"v",
"=",
"(",
"u",
"-",
"1",
")",
"E",
"=",
"[",
"dmp_eval_tail",
"(",
"t",
",",
"A",
",",
"v",
",",
"K",
")",
"for",
"(",
"t",
",",
"_",
")",
"in",
"T",
"]",
"D",
"=",
"dmp_zz_wang_non_divisors",
"(",
"E",
",",
"c",
",",
"ct",
",",
"K",
")",
"if",
"(",
"D",
"is",
"not",
"None",
")",
":",
"return",
"(",
"c",
",",
"h",
",",
"E",
")",
"else",
":",
"raise",
"EvaluationFailed",
"(",
"'no luck'",
")"
] |
wang/eez: test evaluation points for suitability .
|
train
| false
|
13,564
|
def filter_formatdate(val, format):
encoding = locale.getpreferredencoding()
if (not isinstance(val, (datetime, date, time))):
return val
return native_str_to_text(val.strftime(text_to_native_str(format, encoding=encoding)), encoding=encoding)
|
[
"def",
"filter_formatdate",
"(",
"val",
",",
"format",
")",
":",
"encoding",
"=",
"locale",
".",
"getpreferredencoding",
"(",
")",
"if",
"(",
"not",
"isinstance",
"(",
"val",
",",
"(",
"datetime",
",",
"date",
",",
"time",
")",
")",
")",
":",
"return",
"val",
"return",
"native_str_to_text",
"(",
"val",
".",
"strftime",
"(",
"text_to_native_str",
"(",
"format",
",",
"encoding",
"=",
"encoding",
")",
")",
",",
"encoding",
"=",
"encoding",
")"
] |
returns a string representation of a datetime object according to format string .
|
train
| false
|
13,565
|
def get_monitor_doc(var):
doc = None
if (var.__doc__ is not var.__class__.__doc__):
doc = var.__doc__
return doc
|
[
"def",
"get_monitor_doc",
"(",
"var",
")",
":",
"doc",
"=",
"None",
"if",
"(",
"var",
".",
"__doc__",
"is",
"not",
"var",
".",
"__class__",
".",
"__doc__",
")",
":",
"doc",
"=",
"var",
".",
"__doc__",
"return",
"doc"
] |
returns the __doc__ field of var or none .
|
train
| false
|
13,566
|
@public
def xring(symbols, domain, order=lex):
_ring = PolyRing(symbols, domain, order)
return (_ring, _ring.gens)
|
[
"@",
"public",
"def",
"xring",
"(",
"symbols",
",",
"domain",
",",
"order",
"=",
"lex",
")",
":",
"_ring",
"=",
"PolyRing",
"(",
"symbols",
",",
"domain",
",",
"order",
")",
"return",
"(",
"_ring",
",",
"_ring",
".",
"gens",
")"
] |
construct a polynomial ring returning (ring .
|
train
| false
|
13,567
|
def _get_branch_opts(branch, local_branch, all_local_branches, desired_upstream, git_ver=None):
if ((branch is not None) and (branch not in all_local_branches)):
return None
if (git_ver is None):
git_ver = _LooseVersion(__salt__['git.version'](versioninfo=False))
ret = []
if (git_ver >= _LooseVersion('1.8.0')):
ret.extend(['--set-upstream-to', desired_upstream])
else:
ret.append('--set-upstream')
ret.append((local_branch if (branch is None) else branch))
ret.append(desired_upstream)
return ret
|
[
"def",
"_get_branch_opts",
"(",
"branch",
",",
"local_branch",
",",
"all_local_branches",
",",
"desired_upstream",
",",
"git_ver",
"=",
"None",
")",
":",
"if",
"(",
"(",
"branch",
"is",
"not",
"None",
")",
"and",
"(",
"branch",
"not",
"in",
"all_local_branches",
")",
")",
":",
"return",
"None",
"if",
"(",
"git_ver",
"is",
"None",
")",
":",
"git_ver",
"=",
"_LooseVersion",
"(",
"__salt__",
"[",
"'git.version'",
"]",
"(",
"versioninfo",
"=",
"False",
")",
")",
"ret",
"=",
"[",
"]",
"if",
"(",
"git_ver",
">=",
"_LooseVersion",
"(",
"'1.8.0'",
")",
")",
":",
"ret",
".",
"extend",
"(",
"[",
"'--set-upstream-to'",
",",
"desired_upstream",
"]",
")",
"else",
":",
"ret",
".",
"append",
"(",
"'--set-upstream'",
")",
"ret",
".",
"append",
"(",
"(",
"local_branch",
"if",
"(",
"branch",
"is",
"None",
")",
"else",
"branch",
")",
")",
"ret",
".",
"append",
"(",
"desired_upstream",
")",
"return",
"ret"
] |
dry helper to build list of opts for git .
|
train
| true
|
13,569
|
@pytest.fixture(scope=u'session')
def celery_session_worker(request, celery_session_app, celery_includes, celery_worker_pool, celery_worker_parameters):
if (not NO_WORKER):
for module in celery_includes:
celery_session_app.loader.import_task_module(module)
with worker.start_worker(celery_session_app, pool=celery_worker_pool, **celery_worker_parameters) as w:
(yield w)
|
[
"@",
"pytest",
".",
"fixture",
"(",
"scope",
"=",
"u'session'",
")",
"def",
"celery_session_worker",
"(",
"request",
",",
"celery_session_app",
",",
"celery_includes",
",",
"celery_worker_pool",
",",
"celery_worker_parameters",
")",
":",
"if",
"(",
"not",
"NO_WORKER",
")",
":",
"for",
"module",
"in",
"celery_includes",
":",
"celery_session_app",
".",
"loader",
".",
"import_task_module",
"(",
"module",
")",
"with",
"worker",
".",
"start_worker",
"(",
"celery_session_app",
",",
"pool",
"=",
"celery_worker_pool",
",",
"**",
"celery_worker_parameters",
")",
"as",
"w",
":",
"(",
"yield",
"w",
")"
] |
session fixture: start worker that lives throughout test suite .
|
train
| false
|
13,571
|
@register.inclusion_tag(u'includes/editable_loader.html', takes_context=True)
def editable_loader(context):
user = context[u'request'].user
template_vars = {u'has_site_permission': has_site_permission(user), u'request': context[u'request']}
if (settings.INLINE_EDITING_ENABLED and template_vars[u'has_site_permission']):
t = get_template(u'includes/editable_toolbar.html')
template_vars[u'REDIRECT_FIELD_NAME'] = REDIRECT_FIELD_NAME
template_vars[u'editable_obj'] = context.get(u'editable_obj', context.get(u'page', None))
template_vars[u'accounts_logout_url'] = context.get(u'accounts_logout_url', None)
template_vars[u'toolbar'] = t.render(Context(template_vars))
template_vars[u'richtext_media'] = RichTextField().formfield().widget.media
return template_vars
|
[
"@",
"register",
".",
"inclusion_tag",
"(",
"u'includes/editable_loader.html'",
",",
"takes_context",
"=",
"True",
")",
"def",
"editable_loader",
"(",
"context",
")",
":",
"user",
"=",
"context",
"[",
"u'request'",
"]",
".",
"user",
"template_vars",
"=",
"{",
"u'has_site_permission'",
":",
"has_site_permission",
"(",
"user",
")",
",",
"u'request'",
":",
"context",
"[",
"u'request'",
"]",
"}",
"if",
"(",
"settings",
".",
"INLINE_EDITING_ENABLED",
"and",
"template_vars",
"[",
"u'has_site_permission'",
"]",
")",
":",
"t",
"=",
"get_template",
"(",
"u'includes/editable_toolbar.html'",
")",
"template_vars",
"[",
"u'REDIRECT_FIELD_NAME'",
"]",
"=",
"REDIRECT_FIELD_NAME",
"template_vars",
"[",
"u'editable_obj'",
"]",
"=",
"context",
".",
"get",
"(",
"u'editable_obj'",
",",
"context",
".",
"get",
"(",
"u'page'",
",",
"None",
")",
")",
"template_vars",
"[",
"u'accounts_logout_url'",
"]",
"=",
"context",
".",
"get",
"(",
"u'accounts_logout_url'",
",",
"None",
")",
"template_vars",
"[",
"u'toolbar'",
"]",
"=",
"t",
".",
"render",
"(",
"Context",
"(",
"template_vars",
")",
")",
"template_vars",
"[",
"u'richtext_media'",
"]",
"=",
"RichTextField",
"(",
")",
".",
"formfield",
"(",
")",
".",
"widget",
".",
"media",
"return",
"template_vars"
] |
set up the required js/css for the in-line editing toolbar and controls .
|
train
| false
|
13,572
|
def CorrelatedGenerator(rho):
x = random.gauss(0, 1)
(yield x)
sigma = math.sqrt((1 - (rho ** 2)))
while True:
x = random.gauss((x * rho), sigma)
(yield x)
|
[
"def",
"CorrelatedGenerator",
"(",
"rho",
")",
":",
"x",
"=",
"random",
".",
"gauss",
"(",
"0",
",",
"1",
")",
"(",
"yield",
"x",
")",
"sigma",
"=",
"math",
".",
"sqrt",
"(",
"(",
"1",
"-",
"(",
"rho",
"**",
"2",
")",
")",
")",
"while",
"True",
":",
"x",
"=",
"random",
".",
"gauss",
"(",
"(",
"x",
"*",
"rho",
")",
",",
"sigma",
")",
"(",
"yield",
"x",
")"
] |
generates standard normal variates with serial correlation .
|
train
| false
|
13,573
|
def replace_patterns(x, replace):
for (from_, to) in iteritems(replace):
x = x.replace(str(from_), str(to))
return x
|
[
"def",
"replace_patterns",
"(",
"x",
",",
"replace",
")",
":",
"for",
"(",
"from_",
",",
"to",
")",
"in",
"iteritems",
"(",
"replace",
")",
":",
"x",
"=",
"x",
".",
"replace",
"(",
"str",
"(",
"from_",
")",
",",
"str",
"(",
"to",
")",
")",
"return",
"x"
] |
replace replace in string x .
|
train
| false
|
13,574
|
def expm_frechet_block_enlarge(A, E):
n = A.shape[0]
M = np.vstack([np.hstack([A, E]), np.hstack([np.zeros_like(A), A])])
expm_M = scipy.linalg.expm(M)
return (expm_M[:n, :n], expm_M[:n, n:])
|
[
"def",
"expm_frechet_block_enlarge",
"(",
"A",
",",
"E",
")",
":",
"n",
"=",
"A",
".",
"shape",
"[",
"0",
"]",
"M",
"=",
"np",
".",
"vstack",
"(",
"[",
"np",
".",
"hstack",
"(",
"[",
"A",
",",
"E",
"]",
")",
",",
"np",
".",
"hstack",
"(",
"[",
"np",
".",
"zeros_like",
"(",
"A",
")",
",",
"A",
"]",
")",
"]",
")",
"expm_M",
"=",
"scipy",
".",
"linalg",
".",
"expm",
"(",
"M",
")",
"return",
"(",
"expm_M",
"[",
":",
"n",
",",
":",
"n",
"]",
",",
"expm_M",
"[",
":",
"n",
",",
"n",
":",
"]",
")"
] |
this is a helper function .
|
train
| false
|
13,575
|
def test_solve_fixed_trajectory():
(t0, k0) = (0, np.array([5.0]))
results = _compute_fixed_length_solns(model, t0, k0)
for (integrator, numeric_solution) in results.items():
ti = numeric_solution[:, 0]
analytic_solution = solow_analytic_solution(ti, k0, *valid_params)
np.testing.assert_allclose(numeric_solution, analytic_solution)
|
[
"def",
"test_solve_fixed_trajectory",
"(",
")",
":",
"(",
"t0",
",",
"k0",
")",
"=",
"(",
"0",
",",
"np",
".",
"array",
"(",
"[",
"5.0",
"]",
")",
")",
"results",
"=",
"_compute_fixed_length_solns",
"(",
"model",
",",
"t0",
",",
"k0",
")",
"for",
"(",
"integrator",
",",
"numeric_solution",
")",
"in",
"results",
".",
"items",
"(",
")",
":",
"ti",
"=",
"numeric_solution",
"[",
":",
",",
"0",
"]",
"analytic_solution",
"=",
"solow_analytic_solution",
"(",
"ti",
",",
"k0",
",",
"*",
"valid_params",
")",
"np",
".",
"testing",
".",
"assert_allclose",
"(",
"numeric_solution",
",",
"analytic_solution",
")"
] |
testing computation of fixed length solution trajectory .
|
train
| false
|
13,576
|
def parse_ansi(string, strip_ansi=False, parser=ANSI_PARSER, xterm256=False, mxp=False):
return parser.parse_ansi(string, strip_ansi=strip_ansi, xterm256=xterm256, mxp=mxp)
|
[
"def",
"parse_ansi",
"(",
"string",
",",
"strip_ansi",
"=",
"False",
",",
"parser",
"=",
"ANSI_PARSER",
",",
"xterm256",
"=",
"False",
",",
"mxp",
"=",
"False",
")",
":",
"return",
"parser",
".",
"parse_ansi",
"(",
"string",
",",
"strip_ansi",
"=",
"strip_ansi",
",",
"xterm256",
"=",
"xterm256",
",",
"mxp",
"=",
"mxp",
")"
] |
parses a string .
|
train
| false
|
13,579
|
def validate_badge_image(image):
if (image.width != image.height):
raise ValidationError(_(u'The badge image must be square.'))
if (not (image.size < (250 * 1024))):
raise ValidationError(_(u'The badge image file size must be less than 250KB.'))
|
[
"def",
"validate_badge_image",
"(",
"image",
")",
":",
"if",
"(",
"image",
".",
"width",
"!=",
"image",
".",
"height",
")",
":",
"raise",
"ValidationError",
"(",
"_",
"(",
"u'The badge image must be square.'",
")",
")",
"if",
"(",
"not",
"(",
"image",
".",
"size",
"<",
"(",
"250",
"*",
"1024",
")",
")",
")",
":",
"raise",
"ValidationError",
"(",
"_",
"(",
"u'The badge image file size must be less than 250KB.'",
")",
")"
] |
validates that a particular image is small enough to be a badge and square .
|
train
| false
|
13,580
|
def max_score(scores):
lst = sorted_score(scores)
max_score = lst[0][1]
return [(i[0], i[1]) for i in lst if (i[1] == max_score)]
|
[
"def",
"max_score",
"(",
"scores",
")",
":",
"lst",
"=",
"sorted_score",
"(",
"scores",
")",
"max_score",
"=",
"lst",
"[",
"0",
"]",
"[",
"1",
"]",
"return",
"[",
"(",
"i",
"[",
"0",
"]",
",",
"i",
"[",
"1",
"]",
")",
"for",
"i",
"in",
"lst",
"if",
"(",
"i",
"[",
"1",
"]",
"==",
"max_score",
")",
"]"
] |
the max scroe and the persons name .
|
train
| false
|
13,581
|
def p_jump_statement_1(t):
pass
|
[
"def",
"p_jump_statement_1",
"(",
"t",
")",
":",
"pass"
] |
jump_statement : goto id semi .
|
train
| false
|
13,582
|
def _crawl(expr, func, *args, **kwargs):
val = func(expr, *args, **kwargs)
if (val is not None):
return val
new_args = (_crawl(arg, func, *args, **kwargs) for arg in expr.args)
return expr.func(*new_args)
|
[
"def",
"_crawl",
"(",
"expr",
",",
"func",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"val",
"=",
"func",
"(",
"expr",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"if",
"(",
"val",
"is",
"not",
"None",
")",
":",
"return",
"val",
"new_args",
"=",
"(",
"_crawl",
"(",
"arg",
",",
"func",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"for",
"arg",
"in",
"expr",
".",
"args",
")",
"return",
"expr",
".",
"func",
"(",
"*",
"new_args",
")"
] |
crawl the expression tree .
|
train
| false
|
13,584
|
def get_lang_dict(fortype, name=None):
from frappe.translate import get_dict
return get_dict(fortype, name)
|
[
"def",
"get_lang_dict",
"(",
"fortype",
",",
"name",
"=",
"None",
")",
":",
"from",
"frappe",
".",
"translate",
"import",
"get_dict",
"return",
"get_dict",
"(",
"fortype",
",",
"name",
")"
] |
returns all languages in dict format .
|
train
| false
|
13,586
|
def test_label_problems_at_runtime():
@_preprocess_data(label_namer='z')
def func(*args, **kwargs):
pass
with pytest.warns(RuntimeWarning):
func(None, x='a', y='b')
def real_func(x, y):
pass
@_preprocess_data(label_namer='x')
def func(*args, **kwargs):
real_func(**kwargs)
with pytest.raises(TypeError):
func(None, x='a', y='b')
|
[
"def",
"test_label_problems_at_runtime",
"(",
")",
":",
"@",
"_preprocess_data",
"(",
"label_namer",
"=",
"'z'",
")",
"def",
"func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"pass",
"with",
"pytest",
".",
"warns",
"(",
"RuntimeWarning",
")",
":",
"func",
"(",
"None",
",",
"x",
"=",
"'a'",
",",
"y",
"=",
"'b'",
")",
"def",
"real_func",
"(",
"x",
",",
"y",
")",
":",
"pass",
"@",
"_preprocess_data",
"(",
"label_namer",
"=",
"'x'",
")",
"def",
"func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"real_func",
"(",
"**",
"kwargs",
")",
"with",
"pytest",
".",
"raises",
"(",
"TypeError",
")",
":",
"func",
"(",
"None",
",",
"x",
"=",
"'a'",
",",
"y",
"=",
"'b'",
")"
] |
tests for behaviour which would actually be nice to get rid of .
|
train
| false
|
13,587
|
def course_ids_between(start_word, end_word):
valid_courses = []
for course in modulestore().get_courses():
course_id = course.id.to_deprecated_string()
if (start_word.lower() <= course_id.lower() <= end_word.lower()):
valid_courses.append(course.id)
return valid_courses
|
[
"def",
"course_ids_between",
"(",
"start_word",
",",
"end_word",
")",
":",
"valid_courses",
"=",
"[",
"]",
"for",
"course",
"in",
"modulestore",
"(",
")",
".",
"get_courses",
"(",
")",
":",
"course_id",
"=",
"course",
".",
"id",
".",
"to_deprecated_string",
"(",
")",
"if",
"(",
"start_word",
".",
"lower",
"(",
")",
"<=",
"course_id",
".",
"lower",
"(",
")",
"<=",
"end_word",
".",
"lower",
"(",
")",
")",
":",
"valid_courses",
".",
"append",
"(",
"course",
".",
"id",
")",
"return",
"valid_courses"
] |
returns a list of all valid course_ids that fall alphabetically between start_word and end_word .
|
train
| false
|
13,588
|
def formatnumber(n):
parts = list(str(n))
for i in range((len(parts) - 3), 0, (-3)):
parts.insert(i, ',')
return ''.join(parts)
|
[
"def",
"formatnumber",
"(",
"n",
")",
":",
"parts",
"=",
"list",
"(",
"str",
"(",
"n",
")",
")",
"for",
"i",
"in",
"range",
"(",
"(",
"len",
"(",
"parts",
")",
"-",
"3",
")",
",",
"0",
",",
"(",
"-",
"3",
")",
")",
":",
"parts",
".",
"insert",
"(",
"i",
",",
"','",
")",
"return",
"''",
".",
"join",
"(",
"parts",
")"
] |
format a number with beautiful commas .
|
train
| false
|
13,589
|
def corpus2dense(corpus, num_terms, num_docs=None, dtype=np.float32):
if (num_docs is not None):
(docno, result) = ((-1), np.empty((num_terms, num_docs), dtype=dtype))
for (docno, doc) in enumerate(corpus):
result[:, docno] = sparse2full(doc, num_terms)
assert ((docno + 1) == num_docs)
else:
result = np.column_stack((sparse2full(doc, num_terms) for doc in corpus))
return result.astype(dtype)
|
[
"def",
"corpus2dense",
"(",
"corpus",
",",
"num_terms",
",",
"num_docs",
"=",
"None",
",",
"dtype",
"=",
"np",
".",
"float32",
")",
":",
"if",
"(",
"num_docs",
"is",
"not",
"None",
")",
":",
"(",
"docno",
",",
"result",
")",
"=",
"(",
"(",
"-",
"1",
")",
",",
"np",
".",
"empty",
"(",
"(",
"num_terms",
",",
"num_docs",
")",
",",
"dtype",
"=",
"dtype",
")",
")",
"for",
"(",
"docno",
",",
"doc",
")",
"in",
"enumerate",
"(",
"corpus",
")",
":",
"result",
"[",
":",
",",
"docno",
"]",
"=",
"sparse2full",
"(",
"doc",
",",
"num_terms",
")",
"assert",
"(",
"(",
"docno",
"+",
"1",
")",
"==",
"num_docs",
")",
"else",
":",
"result",
"=",
"np",
".",
"column_stack",
"(",
"(",
"sparse2full",
"(",
"doc",
",",
"num_terms",
")",
"for",
"doc",
"in",
"corpus",
")",
")",
"return",
"result",
".",
"astype",
"(",
"dtype",
")"
] |
convert corpus into a dense np array .
|
train
| false
|
13,590
|
def make_global_ns(name):
if is_private(name):
raise ValueError(('cannot turn [%s] into a global name' % name))
if (not is_global(name)):
name = (SEP + name)
if (name[(-1)] != SEP):
name = (name + SEP)
return name
|
[
"def",
"make_global_ns",
"(",
"name",
")",
":",
"if",
"is_private",
"(",
"name",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'cannot turn [%s] into a global name'",
"%",
"name",
")",
")",
"if",
"(",
"not",
"is_global",
"(",
"name",
")",
")",
":",
"name",
"=",
"(",
"SEP",
"+",
"name",
")",
"if",
"(",
"name",
"[",
"(",
"-",
"1",
")",
"]",
"!=",
"SEP",
")",
":",
"name",
"=",
"(",
"name",
"+",
"SEP",
")",
"return",
"name"
] |
convert name to a global name with a trailing namespace separator .
|
train
| false
|
13,591
|
def get_targets():
logs = NodeLog.find((((((((((Q('action', 'eq', 'registration_initiated') | Q('action', 'eq', 'registration_approved')) | Q('action', 'eq', 'registration_cancelled')) | Q('action', 'eq', 'retraction_initiated')) | Q('action', 'eq', 'retraction_approved')) | Q('action', 'eq', 'retraction_cancelled')) | Q('action', 'eq', 'embargo_initiated')) | Q('action', 'eq', 'embargo_approved')) | Q('action', 'eq', 'embargo_completed')) | Q('action', 'eq', 'embargo_cancelled')))
return logs
|
[
"def",
"get_targets",
"(",
")",
":",
"logs",
"=",
"NodeLog",
".",
"find",
"(",
"(",
"(",
"(",
"(",
"(",
"(",
"(",
"(",
"(",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'registration_initiated'",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'registration_approved'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'registration_cancelled'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'retraction_initiated'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'retraction_approved'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'retraction_cancelled'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'embargo_initiated'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'embargo_approved'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'embargo_completed'",
")",
")",
"|",
"Q",
"(",
"'action'",
",",
"'eq'",
",",
"'embargo_cancelled'",
")",
")",
")",
"return",
"logs"
] |
get addongithubnodesettings records with authorization and a non-null webhook .
|
train
| false
|
13,592
|
def _massage_stats(request, stats):
path = stats['path']
normalized = request.fs.normpath(path)
return {'path': normalized, 'name': stats['name'], 'stats': stats.to_json_dict(), 'mtime': (datetime.fromtimestamp(stats['mtime']).strftime('%B %d, %Y %I:%M %p') if stats['mtime'] else ''), 'humansize': filesizeformat(stats['size']), 'type': filetype(stats['mode']), 'rwx': rwx(stats['mode'], stats['aclBit']), 'mode': stringformat(stats['mode'], 'o'), 'url': reverse('filebrowser.views.view', kwargs=dict(path=normalized)), 'is_sentry_managed': request.fs.is_sentry_managed(path)}
|
[
"def",
"_massage_stats",
"(",
"request",
",",
"stats",
")",
":",
"path",
"=",
"stats",
"[",
"'path'",
"]",
"normalized",
"=",
"request",
".",
"fs",
".",
"normpath",
"(",
"path",
")",
"return",
"{",
"'path'",
":",
"normalized",
",",
"'name'",
":",
"stats",
"[",
"'name'",
"]",
",",
"'stats'",
":",
"stats",
".",
"to_json_dict",
"(",
")",
",",
"'mtime'",
":",
"(",
"datetime",
".",
"fromtimestamp",
"(",
"stats",
"[",
"'mtime'",
"]",
")",
".",
"strftime",
"(",
"'%B %d, %Y %I:%M %p'",
")",
"if",
"stats",
"[",
"'mtime'",
"]",
"else",
"''",
")",
",",
"'humansize'",
":",
"filesizeformat",
"(",
"stats",
"[",
"'size'",
"]",
")",
",",
"'type'",
":",
"filetype",
"(",
"stats",
"[",
"'mode'",
"]",
")",
",",
"'rwx'",
":",
"rwx",
"(",
"stats",
"[",
"'mode'",
"]",
",",
"stats",
"[",
"'aclBit'",
"]",
")",
",",
"'mode'",
":",
"stringformat",
"(",
"stats",
"[",
"'mode'",
"]",
",",
"'o'",
")",
",",
"'url'",
":",
"reverse",
"(",
"'filebrowser.views.view'",
",",
"kwargs",
"=",
"dict",
"(",
"path",
"=",
"normalized",
")",
")",
",",
"'is_sentry_managed'",
":",
"request",
".",
"fs",
".",
"is_sentry_managed",
"(",
"path",
")",
"}"
] |
massage a stats record as returned by the filesystem implementation into the format that the views would like it in .
|
train
| false
|
13,593
|
def zero_remove(data, mask):
new_mask = mask.copy()
new_mask[(data == 0)] = 0
return new_mask
|
[
"def",
"zero_remove",
"(",
"data",
",",
"mask",
")",
":",
"new_mask",
"=",
"mask",
".",
"copy",
"(",
")",
"new_mask",
"[",
"(",
"data",
"==",
"0",
")",
"]",
"=",
"0",
"return",
"new_mask"
] |
modify inputted mask to also mask out zero values .
|
train
| false
|
13,594
|
def get_file_from_request(ext=None, folder=None, name='file'):
if (ext is None):
ext = []
print ('get_file_from_request() INVOKED. We have: request.files = %r' % request.files)
if (name not in request.files):
raise NotFoundError('File not found')
uploaded_file = request.files[name]
if (uploaded_file.filename == ''):
raise NotFoundError('File not found')
if (not _allowed_file(uploaded_file.filename, ext)):
raise NotFoundError('Invalid file type')
if (not folder):
folder = app.config['UPLOAD_FOLDER']
else:
with app.app_context():
folder = (app.config['BASE_DIR'] + folder)
filename = secure_filename(uploaded_file.filename)
uploaded_file.save(os.path.join(folder, filename))
return os.path.join(folder, filename)
|
[
"def",
"get_file_from_request",
"(",
"ext",
"=",
"None",
",",
"folder",
"=",
"None",
",",
"name",
"=",
"'file'",
")",
":",
"if",
"(",
"ext",
"is",
"None",
")",
":",
"ext",
"=",
"[",
"]",
"print",
"(",
"'get_file_from_request() INVOKED. We have: request.files = %r'",
"%",
"request",
".",
"files",
")",
"if",
"(",
"name",
"not",
"in",
"request",
".",
"files",
")",
":",
"raise",
"NotFoundError",
"(",
"'File not found'",
")",
"uploaded_file",
"=",
"request",
".",
"files",
"[",
"name",
"]",
"if",
"(",
"uploaded_file",
".",
"filename",
"==",
"''",
")",
":",
"raise",
"NotFoundError",
"(",
"'File not found'",
")",
"if",
"(",
"not",
"_allowed_file",
"(",
"uploaded_file",
".",
"filename",
",",
"ext",
")",
")",
":",
"raise",
"NotFoundError",
"(",
"'Invalid file type'",
")",
"if",
"(",
"not",
"folder",
")",
":",
"folder",
"=",
"app",
".",
"config",
"[",
"'UPLOAD_FOLDER'",
"]",
"else",
":",
"with",
"app",
".",
"app_context",
"(",
")",
":",
"folder",
"=",
"(",
"app",
".",
"config",
"[",
"'BASE_DIR'",
"]",
"+",
"folder",
")",
"filename",
"=",
"secure_filename",
"(",
"uploaded_file",
".",
"filename",
")",
"uploaded_file",
".",
"save",
"(",
"os",
".",
"path",
".",
"join",
"(",
"folder",
",",
"filename",
")",
")",
"return",
"os",
".",
"path",
".",
"join",
"(",
"folder",
",",
"filename",
")"
] |
get file from a request .
|
train
| false
|
13,595
|
def unixTime():
return systime.time()
|
[
"def",
"unixTime",
"(",
")",
":",
"return",
"systime",
".",
"time",
"(",
")"
] |
return the current time in seconds with high precision (unix version .
|
train
| false
|
13,596
|
def testing_warn(msg, stacklevel=3):
filename = 'sqlalchemy.testing.warnings'
lineno = 1
if isinstance(msg, util.string_types):
warnings.warn_explicit(msg, sa_exc.SAWarning, filename, lineno)
else:
warnings.warn_explicit(msg, filename, lineno)
|
[
"def",
"testing_warn",
"(",
"msg",
",",
"stacklevel",
"=",
"3",
")",
":",
"filename",
"=",
"'sqlalchemy.testing.warnings'",
"lineno",
"=",
"1",
"if",
"isinstance",
"(",
"msg",
",",
"util",
".",
"string_types",
")",
":",
"warnings",
".",
"warn_explicit",
"(",
"msg",
",",
"sa_exc",
".",
"SAWarning",
",",
"filename",
",",
"lineno",
")",
"else",
":",
"warnings",
".",
"warn_explicit",
"(",
"msg",
",",
"filename",
",",
"lineno",
")"
] |
replaces sqlalchemy .
|
train
| false
|
13,597
|
def toChunk(data):
return (('%x\r\n' % len(data)), data, '\r\n')
|
[
"def",
"toChunk",
"(",
"data",
")",
":",
"return",
"(",
"(",
"'%x\\r\\n'",
"%",
"len",
"(",
"data",
")",
")",
",",
"data",
",",
"'\\r\\n'",
")"
] |
convert string to a chunk .
|
train
| false
|
13,598
|
def gravatar(email, default_avatar_url=settings.DEFAULT_AVATAR_URL, size=175, rating='pg'):
url = GRAVATAR_URL.format(emaildigest=md5(email).hexdigest())
url = urlparams(url, d=utils.absolutify(default_avatar_url), s=size, r=rating)
return url
|
[
"def",
"gravatar",
"(",
"email",
",",
"default_avatar_url",
"=",
"settings",
".",
"DEFAULT_AVATAR_URL",
",",
"size",
"=",
"175",
",",
"rating",
"=",
"'pg'",
")",
":",
"url",
"=",
"GRAVATAR_URL",
".",
"format",
"(",
"emaildigest",
"=",
"md5",
"(",
"email",
")",
".",
"hexdigest",
"(",
")",
")",
"url",
"=",
"urlparams",
"(",
"url",
",",
"d",
"=",
"utils",
".",
"absolutify",
"(",
"default_avatar_url",
")",
",",
"s",
"=",
"size",
",",
"r",
"=",
"rating",
")",
"return",
"url"
] |
hacked from djangosnippets .
|
train
| false
|
13,600
|
def getFeedRateMinute(feedRateMinute, splitLine):
indexOfF = getIndexOfStartingWithSecond('F', splitLine)
if (indexOfF > 0):
return getDoubleAfterFirstLetter(splitLine[indexOfF])
return feedRateMinute
|
[
"def",
"getFeedRateMinute",
"(",
"feedRateMinute",
",",
"splitLine",
")",
":",
"indexOfF",
"=",
"getIndexOfStartingWithSecond",
"(",
"'F'",
",",
"splitLine",
")",
"if",
"(",
"indexOfF",
">",
"0",
")",
":",
"return",
"getDoubleAfterFirstLetter",
"(",
"splitLine",
"[",
"indexOfF",
"]",
")",
"return",
"feedRateMinute"
] |
get the feed rate per minute if the split line has a feed rate .
|
train
| false
|
13,601
|
def humanitarian_id():
channel = settings.get_auth_humanitarian_id()
if (not channel):
redirect(URL(f='user', args=request.args, vars=get_vars))
from s3oauth import HumanitarianIDAccount
auth.settings.login_form = HumanitarianIDAccount(channel)
form = auth()
return {'form': form}
|
[
"def",
"humanitarian_id",
"(",
")",
":",
"channel",
"=",
"settings",
".",
"get_auth_humanitarian_id",
"(",
")",
"if",
"(",
"not",
"channel",
")",
":",
"redirect",
"(",
"URL",
"(",
"f",
"=",
"'user'",
",",
"args",
"=",
"request",
".",
"args",
",",
"vars",
"=",
"get_vars",
")",
")",
"from",
"s3oauth",
"import",
"HumanitarianIDAccount",
"auth",
".",
"settings",
".",
"login_form",
"=",
"HumanitarianIDAccount",
"(",
"channel",
")",
"form",
"=",
"auth",
"(",
")",
"return",
"{",
"'form'",
":",
"form",
"}"
] |
login using humanitarian .
|
train
| false
|
13,602
|
def runs(seq, op=gt):
cycles = []
seq = iter(seq)
try:
run = [next(seq)]
except StopIteration:
return []
while True:
try:
ei = next(seq)
except StopIteration:
break
if op(ei, run[(-1)]):
run.append(ei)
continue
else:
cycles.append(run)
run = [ei]
if run:
cycles.append(run)
return cycles
|
[
"def",
"runs",
"(",
"seq",
",",
"op",
"=",
"gt",
")",
":",
"cycles",
"=",
"[",
"]",
"seq",
"=",
"iter",
"(",
"seq",
")",
"try",
":",
"run",
"=",
"[",
"next",
"(",
"seq",
")",
"]",
"except",
"StopIteration",
":",
"return",
"[",
"]",
"while",
"True",
":",
"try",
":",
"ei",
"=",
"next",
"(",
"seq",
")",
"except",
"StopIteration",
":",
"break",
"if",
"op",
"(",
"ei",
",",
"run",
"[",
"(",
"-",
"1",
")",
"]",
")",
":",
"run",
".",
"append",
"(",
"ei",
")",
"continue",
"else",
":",
"cycles",
".",
"append",
"(",
"run",
")",
"run",
"=",
"[",
"ei",
"]",
"if",
"run",
":",
"cycles",
".",
"append",
"(",
"run",
")",
"return",
"cycles"
] |
group the sequence into lists in which successive elements all compare the same with the comparison operator .
|
train
| false
|
13,603
|
@login_required
@ensure_csrf_cookie
@require_http_methods(('GET', 'POST', 'PUT', 'DELETE'))
def course_team_handler(request, course_key_string=None, email=None):
course_key = (CourseKey.from_string(course_key_string) if course_key_string else None)
if ('application/json' in request.META.get('HTTP_ACCEPT', 'application/json')):
return _course_team_user(request, course_key, email)
elif (request.method == 'GET'):
return _manage_users(request, course_key)
else:
return HttpResponseNotFound()
|
[
"@",
"login_required",
"@",
"ensure_csrf_cookie",
"@",
"require_http_methods",
"(",
"(",
"'GET'",
",",
"'POST'",
",",
"'PUT'",
",",
"'DELETE'",
")",
")",
"def",
"course_team_handler",
"(",
"request",
",",
"course_key_string",
"=",
"None",
",",
"email",
"=",
"None",
")",
":",
"course_key",
"=",
"(",
"CourseKey",
".",
"from_string",
"(",
"course_key_string",
")",
"if",
"course_key_string",
"else",
"None",
")",
"if",
"(",
"'application/json'",
"in",
"request",
".",
"META",
".",
"get",
"(",
"'HTTP_ACCEPT'",
",",
"'application/json'",
")",
")",
":",
"return",
"_course_team_user",
"(",
"request",
",",
"course_key",
",",
"email",
")",
"elif",
"(",
"request",
".",
"method",
"==",
"'GET'",
")",
":",
"return",
"_manage_users",
"(",
"request",
",",
"course_key",
")",
"else",
":",
"return",
"HttpResponseNotFound",
"(",
")"
] |
the restful handler for course team users .
|
train
| false
|
13,604
|
def Enum(*args, **kwargs):
def getLabel(cls, val):
' Get a string label for the current value of the enum '
return cls.__labels[val]
def validate(cls, val):
' Returns True if val is a valid value for the enumeration '
return (val in cls.__values)
def getValues(cls):
' Returns a list of all the possible values for this enum '
return list(cls.__values)
def getLabels(cls):
' Returns a list of all possible labels for this enum '
return list(cls.__labels.values())
def getValue(cls, label):
' Returns value given a label '
return cls.__labels[label]
for arg in (list(args) + kwargs.keys()):
if (type(arg) is not str):
raise TypeError('Enum arg {0} must be a string'.format(arg))
if (not __isidentifier(arg)):
raise ValueError("Invalid enum value '{0}'. '{0}' is not a valid identifier".format(arg))
kwargs.update(zip(args, args))
newType = type('Enum', (object,), kwargs)
newType.__labels = dict(((v, k) for (k, v) in kwargs.iteritems()))
newType.__values = set(newType.__labels.keys())
newType.getLabel = functools.partial(getLabel, newType)
newType.validate = functools.partial(validate, newType)
newType.getValues = functools.partial(getValues, newType)
newType.getLabels = functools.partial(getLabels, newType)
newType.getValue = functools.partial(getValue, newType)
return newType
|
[
"def",
"Enum",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"def",
"getLabel",
"(",
"cls",
",",
"val",
")",
":",
"return",
"cls",
".",
"__labels",
"[",
"val",
"]",
"def",
"validate",
"(",
"cls",
",",
"val",
")",
":",
"return",
"(",
"val",
"in",
"cls",
".",
"__values",
")",
"def",
"getValues",
"(",
"cls",
")",
":",
"return",
"list",
"(",
"cls",
".",
"__values",
")",
"def",
"getLabels",
"(",
"cls",
")",
":",
"return",
"list",
"(",
"cls",
".",
"__labels",
".",
"values",
"(",
")",
")",
"def",
"getValue",
"(",
"cls",
",",
"label",
")",
":",
"return",
"cls",
".",
"__labels",
"[",
"label",
"]",
"for",
"arg",
"in",
"(",
"list",
"(",
"args",
")",
"+",
"kwargs",
".",
"keys",
"(",
")",
")",
":",
"if",
"(",
"type",
"(",
"arg",
")",
"is",
"not",
"str",
")",
":",
"raise",
"TypeError",
"(",
"'Enum arg {0} must be a string'",
".",
"format",
"(",
"arg",
")",
")",
"if",
"(",
"not",
"__isidentifier",
"(",
"arg",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Invalid enum value '{0}'. '{0}' is not a valid identifier\"",
".",
"format",
"(",
"arg",
")",
")",
"kwargs",
".",
"update",
"(",
"zip",
"(",
"args",
",",
"args",
")",
")",
"newType",
"=",
"type",
"(",
"'Enum'",
",",
"(",
"object",
",",
")",
",",
"kwargs",
")",
"newType",
".",
"__labels",
"=",
"dict",
"(",
"(",
"(",
"v",
",",
"k",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"kwargs",
".",
"iteritems",
"(",
")",
")",
")",
"newType",
".",
"__values",
"=",
"set",
"(",
"newType",
".",
"__labels",
".",
"keys",
"(",
")",
")",
"newType",
".",
"getLabel",
"=",
"functools",
".",
"partial",
"(",
"getLabel",
",",
"newType",
")",
"newType",
".",
"validate",
"=",
"functools",
".",
"partial",
"(",
"validate",
",",
"newType",
")",
"newType",
".",
"getValues",
"=",
"functools",
".",
"partial",
"(",
"getValues",
",",
"newType",
")",
"newType",
".",
"getLabels",
"=",
"functools",
".",
"partial",
"(",
"getLabels",
",",
"newType",
")",
"newType",
".",
"getValue",
"=",
"functools",
".",
"partial",
"(",
"getValue",
",",
"newType",
")",
"return",
"newType"
] |
enum is an adapter to another field: it will just change its display attribute .
|
train
| true
|
13,605
|
def neutron_public_url(catalog):
for i in catalog['access']['serviceCatalog']:
if (i['type'] == 'network'):
for endpoint in i['endpoints']:
return endpoint['publicURL']
|
[
"def",
"neutron_public_url",
"(",
"catalog",
")",
":",
"for",
"i",
"in",
"catalog",
"[",
"'access'",
"]",
"[",
"'serviceCatalog'",
"]",
":",
"if",
"(",
"i",
"[",
"'type'",
"]",
"==",
"'network'",
")",
":",
"for",
"endpoint",
"in",
"i",
"[",
"'endpoints'",
"]",
":",
"return",
"endpoint",
"[",
"'publicURL'",
"]"
] |
get neutron publicurl .
|
train
| false
|
13,608
|
def blast_genome(seqs, blast_db, e_value, max_hits, word_size, working_dir, blast_mat_root, extra_params=[], DEBUG=True):
params = {'-M': 'BLOSUM62', '-a': '1', '-e': e_value, '-b': max_hits, '-W': word_size, '-v': max_hits, '-m': '9', '-p': 'blastn'}
params.update(extra_params)
output = blast_seqs(seqs, Blastall, blast_db=blast_db, params=params, WorkingDir=working_dir, add_seq_names=False, blast_mat_root=blast_mat_root)
raw_output = [x for x in output['StdOut']]
return raw_output
|
[
"def",
"blast_genome",
"(",
"seqs",
",",
"blast_db",
",",
"e_value",
",",
"max_hits",
",",
"word_size",
",",
"working_dir",
",",
"blast_mat_root",
",",
"extra_params",
"=",
"[",
"]",
",",
"DEBUG",
"=",
"True",
")",
":",
"params",
"=",
"{",
"'-M'",
":",
"'BLOSUM62'",
",",
"'-a'",
":",
"'1'",
",",
"'-e'",
":",
"e_value",
",",
"'-b'",
":",
"max_hits",
",",
"'-W'",
":",
"word_size",
",",
"'-v'",
":",
"max_hits",
",",
"'-m'",
":",
"'9'",
",",
"'-p'",
":",
"'blastn'",
"}",
"params",
".",
"update",
"(",
"extra_params",
")",
"output",
"=",
"blast_seqs",
"(",
"seqs",
",",
"Blastall",
",",
"blast_db",
"=",
"blast_db",
",",
"params",
"=",
"params",
",",
"WorkingDir",
"=",
"working_dir",
",",
"add_seq_names",
"=",
"False",
",",
"blast_mat_root",
"=",
"blast_mat_root",
")",
"raw_output",
"=",
"[",
"x",
"for",
"x",
"in",
"output",
"[",
"'StdOut'",
"]",
"]",
"return",
"raw_output"
] |
blast sequences against all genes in a genome seqs -- input sequences as strings blast_db -- path to blast database e_value -- e_value max_hits -- maximum sequences detected by blast to show word_size -- word size for initial blast screen .
|
train
| false
|
13,609
|
def test_random_sample_size():
a = db.from_sequence(range(1000), npartitions=5)
assert (10 < len(list(a.random_sample(0.1, 42))) < 300)
|
[
"def",
"test_random_sample_size",
"(",
")",
":",
"a",
"=",
"db",
".",
"from_sequence",
"(",
"range",
"(",
"1000",
")",
",",
"npartitions",
"=",
"5",
")",
"assert",
"(",
"10",
"<",
"len",
"(",
"list",
"(",
"a",
".",
"random_sample",
"(",
"0.1",
",",
"42",
")",
")",
")",
"<",
"300",
")"
] |
number of randomly sampled elements are in the expected range .
|
train
| false
|
13,610
|
@testing.requires_testing_data
def test_plot_source_spectrogram():
sample_src = read_source_spaces(op.join(subjects_dir, 'sample', 'bem', 'sample-oct-6-src.fif'))
vertices = [s['vertno'] for s in sample_src]
n_times = 5
n_verts = sum((len(v) for v in vertices))
stc_data = np.ones((n_verts, n_times))
stc = SourceEstimate(stc_data, vertices, 1, 1)
plot_source_spectrogram([stc, stc], [[1, 2], [3, 4]])
assert_raises(ValueError, plot_source_spectrogram, [], [])
assert_raises(ValueError, plot_source_spectrogram, [stc, stc], [[1, 2], [3, 4]], tmin=0)
assert_raises(ValueError, plot_source_spectrogram, [stc, stc], [[1, 2], [3, 4]], tmax=7)
|
[
"@",
"testing",
".",
"requires_testing_data",
"def",
"test_plot_source_spectrogram",
"(",
")",
":",
"sample_src",
"=",
"read_source_spaces",
"(",
"op",
".",
"join",
"(",
"subjects_dir",
",",
"'sample'",
",",
"'bem'",
",",
"'sample-oct-6-src.fif'",
")",
")",
"vertices",
"=",
"[",
"s",
"[",
"'vertno'",
"]",
"for",
"s",
"in",
"sample_src",
"]",
"n_times",
"=",
"5",
"n_verts",
"=",
"sum",
"(",
"(",
"len",
"(",
"v",
")",
"for",
"v",
"in",
"vertices",
")",
")",
"stc_data",
"=",
"np",
".",
"ones",
"(",
"(",
"n_verts",
",",
"n_times",
")",
")",
"stc",
"=",
"SourceEstimate",
"(",
"stc_data",
",",
"vertices",
",",
"1",
",",
"1",
")",
"plot_source_spectrogram",
"(",
"[",
"stc",
",",
"stc",
"]",
",",
"[",
"[",
"1",
",",
"2",
"]",
",",
"[",
"3",
",",
"4",
"]",
"]",
")",
"assert_raises",
"(",
"ValueError",
",",
"plot_source_spectrogram",
",",
"[",
"]",
",",
"[",
"]",
")",
"assert_raises",
"(",
"ValueError",
",",
"plot_source_spectrogram",
",",
"[",
"stc",
",",
"stc",
"]",
",",
"[",
"[",
"1",
",",
"2",
"]",
",",
"[",
"3",
",",
"4",
"]",
"]",
",",
"tmin",
"=",
"0",
")",
"assert_raises",
"(",
"ValueError",
",",
"plot_source_spectrogram",
",",
"[",
"stc",
",",
"stc",
"]",
",",
"[",
"[",
"1",
",",
"2",
"]",
",",
"[",
"3",
",",
"4",
"]",
"]",
",",
"tmax",
"=",
"7",
")"
] |
test plotting of source spectrogram .
|
train
| false
|
13,613
|
def CohenEffectSize(group1, group2):
diff = (group1.mean() - group2.mean())
(n1, n2) = (len(group1), len(group2))
var1 = group1.var()
var2 = group2.var()
pooled_var = (((n1 * var1) + (n2 * var2)) / (n1 + n2))
d = (diff / math.sqrt(pooled_var))
return d
|
[
"def",
"CohenEffectSize",
"(",
"group1",
",",
"group2",
")",
":",
"diff",
"=",
"(",
"group1",
".",
"mean",
"(",
")",
"-",
"group2",
".",
"mean",
"(",
")",
")",
"(",
"n1",
",",
"n2",
")",
"=",
"(",
"len",
"(",
"group1",
")",
",",
"len",
"(",
"group2",
")",
")",
"var1",
"=",
"group1",
".",
"var",
"(",
")",
"var2",
"=",
"group2",
".",
"var",
"(",
")",
"pooled_var",
"=",
"(",
"(",
"(",
"n1",
"*",
"var1",
")",
"+",
"(",
"n2",
"*",
"var2",
")",
")",
"/",
"(",
"n1",
"+",
"n2",
")",
")",
"d",
"=",
"(",
"diff",
"/",
"math",
".",
"sqrt",
"(",
"pooled_var",
")",
")",
"return",
"d"
] |
compute cohens d .
|
train
| false
|
13,614
|
def dedent_lines(lines):
return textwrap.dedent('\n'.join(lines)).split('\n')
|
[
"def",
"dedent_lines",
"(",
"lines",
")",
":",
"return",
"textwrap",
".",
"dedent",
"(",
"'\\n'",
".",
"join",
"(",
"lines",
")",
")",
".",
"split",
"(",
"'\\n'",
")"
] |
deindent a list of lines maximally .
|
train
| false
|
13,615
|
def getDisplayToolButtonsRepository(directoryPath, importantFileNames, names, repository):
displayToolButtons = []
for name in names:
displayToolButton = DisplayToolButton().getFromPath((name in importantFileNames), name, os.path.join(directoryPath, name), repository)
displayToolButtons.append(displayToolButton)
return displayToolButtons
|
[
"def",
"getDisplayToolButtonsRepository",
"(",
"directoryPath",
",",
"importantFileNames",
",",
"names",
",",
"repository",
")",
":",
"displayToolButtons",
"=",
"[",
"]",
"for",
"name",
"in",
"names",
":",
"displayToolButton",
"=",
"DisplayToolButton",
"(",
")",
".",
"getFromPath",
"(",
"(",
"name",
"in",
"importantFileNames",
")",
",",
"name",
",",
"os",
".",
"path",
".",
"join",
"(",
"directoryPath",
",",
"name",
")",
",",
"repository",
")",
"displayToolButtons",
".",
"append",
"(",
"displayToolButton",
")",
"return",
"displayToolButtons"
] |
get the display tool buttons .
|
train
| false
|
13,617
|
def IsPacificDST(now):
pst = time.gmtime(now)
year = pst[0]
assert (year >= 2007)
begin = calendar.timegm((year, 3, 8, 2, 0, 0, 0, 0, 0))
while (time.gmtime(begin).tm_wday != SUNDAY):
begin += DAY
end = calendar.timegm((year, 11, 1, 2, 0, 0, 0, 0, 0))
while (time.gmtime(end).tm_wday != SUNDAY):
end += DAY
return (begin <= now < end)
|
[
"def",
"IsPacificDST",
"(",
"now",
")",
":",
"pst",
"=",
"time",
".",
"gmtime",
"(",
"now",
")",
"year",
"=",
"pst",
"[",
"0",
"]",
"assert",
"(",
"year",
">=",
"2007",
")",
"begin",
"=",
"calendar",
".",
"timegm",
"(",
"(",
"year",
",",
"3",
",",
"8",
",",
"2",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
")",
")",
"while",
"(",
"time",
".",
"gmtime",
"(",
"begin",
")",
".",
"tm_wday",
"!=",
"SUNDAY",
")",
":",
"begin",
"+=",
"DAY",
"end",
"=",
"calendar",
".",
"timegm",
"(",
"(",
"year",
",",
"11",
",",
"1",
",",
"2",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
",",
"0",
")",
")",
"while",
"(",
"time",
".",
"gmtime",
"(",
"end",
")",
".",
"tm_wday",
"!=",
"SUNDAY",
")",
":",
"end",
"+=",
"DAY",
"return",
"(",
"begin",
"<=",
"now",
"<",
"end",
")"
] |
helper for pacifictime to decide whether now is pacific dst .
|
train
| false
|
13,619
|
def getAppExt(loops=0):
bb = '!\xff\x0b'
bb += 'NETSCAPE2.0'
bb += '\x03\x01'
if (loops == 0):
loops = ((2 ** 16) - 1)
bb += intToBin(loops)
bb += '\x00'
return bb
|
[
"def",
"getAppExt",
"(",
"loops",
"=",
"0",
")",
":",
"bb",
"=",
"'!\\xff\\x0b'",
"bb",
"+=",
"'NETSCAPE2.0'",
"bb",
"+=",
"'\\x03\\x01'",
"if",
"(",
"loops",
"==",
"0",
")",
":",
"loops",
"=",
"(",
"(",
"2",
"**",
"16",
")",
"-",
"1",
")",
"bb",
"+=",
"intToBin",
"(",
"loops",
")",
"bb",
"+=",
"'\\x00'",
"return",
"bb"
] |
application extention .
|
train
| false
|
13,620
|
def test_run_tb():
with TemporaryDirectory() as td:
path = pjoin(td, 'foo.py')
with open(path, 'w') as f:
f.write('\n'.join(['def foo():', ' return bar()', 'def bar():', " raise RuntimeError('hello!')", 'foo()']))
with capture_output() as io:
_ip.magic('run {}'.format(path))
out = io.stdout
nt.assert_not_in('execfile', out)
nt.assert_in('RuntimeError', out)
nt.assert_equal(out.count('---->'), 3)
|
[
"def",
"test_run_tb",
"(",
")",
":",
"with",
"TemporaryDirectory",
"(",
")",
"as",
"td",
":",
"path",
"=",
"pjoin",
"(",
"td",
",",
"'foo.py'",
")",
"with",
"open",
"(",
"path",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"'\\n'",
".",
"join",
"(",
"[",
"'def foo():'",
",",
"' return bar()'",
",",
"'def bar():'",
",",
"\" raise RuntimeError('hello!')\"",
",",
"'foo()'",
"]",
")",
")",
"with",
"capture_output",
"(",
")",
"as",
"io",
":",
"_ip",
".",
"magic",
"(",
"'run {}'",
".",
"format",
"(",
"path",
")",
")",
"out",
"=",
"io",
".",
"stdout",
"nt",
".",
"assert_not_in",
"(",
"'execfile'",
",",
"out",
")",
"nt",
".",
"assert_in",
"(",
"'RuntimeError'",
",",
"out",
")",
"nt",
".",
"assert_equal",
"(",
"out",
".",
"count",
"(",
"'---->'",
")",
",",
"3",
")"
] |
test traceback offset in %run .
|
train
| false
|
13,621
|
def _lg_undirected(G, selfloops=False, create_using=None):
if (create_using is None):
L = G.__class__()
else:
L = create_using
get_edges = _edge_func(G)
sorted_node = _node_func(G)
shift = (0 if selfloops else 1)
edges = set([])
for u in G:
nodes = [sorted_node(*x) for x in get_edges(u)]
if (len(nodes) == 1):
L.add_node(nodes[0])
for (i, a) in enumerate(nodes):
edges.update([_sorted_edge(a, b) for b in nodes[(i + shift):]])
L.add_edges_from(edges)
return L
|
[
"def",
"_lg_undirected",
"(",
"G",
",",
"selfloops",
"=",
"False",
",",
"create_using",
"=",
"None",
")",
":",
"if",
"(",
"create_using",
"is",
"None",
")",
":",
"L",
"=",
"G",
".",
"__class__",
"(",
")",
"else",
":",
"L",
"=",
"create_using",
"get_edges",
"=",
"_edge_func",
"(",
"G",
")",
"sorted_node",
"=",
"_node_func",
"(",
"G",
")",
"shift",
"=",
"(",
"0",
"if",
"selfloops",
"else",
"1",
")",
"edges",
"=",
"set",
"(",
"[",
"]",
")",
"for",
"u",
"in",
"G",
":",
"nodes",
"=",
"[",
"sorted_node",
"(",
"*",
"x",
")",
"for",
"x",
"in",
"get_edges",
"(",
"u",
")",
"]",
"if",
"(",
"len",
"(",
"nodes",
")",
"==",
"1",
")",
":",
"L",
".",
"add_node",
"(",
"nodes",
"[",
"0",
"]",
")",
"for",
"(",
"i",
",",
"a",
")",
"in",
"enumerate",
"(",
"nodes",
")",
":",
"edges",
".",
"update",
"(",
"[",
"_sorted_edge",
"(",
"a",
",",
"b",
")",
"for",
"b",
"in",
"nodes",
"[",
"(",
"i",
"+",
"shift",
")",
":",
"]",
"]",
")",
"L",
".",
"add_edges_from",
"(",
"edges",
")",
"return",
"L"
] |
return the line graph l of the graph g .
|
train
| false
|
13,622
|
def is_internal_attribute(obj, attr):
if isinstance(obj, types.FunctionType):
if (attr in UNSAFE_FUNCTION_ATTRIBUTES):
return True
elif isinstance(obj, types.MethodType):
if ((attr in UNSAFE_FUNCTION_ATTRIBUTES) or (attr in UNSAFE_METHOD_ATTRIBUTES)):
return True
elif isinstance(obj, type):
if (attr == 'mro'):
return True
elif isinstance(obj, (types.CodeType, types.TracebackType, types.FrameType)):
return True
elif isinstance(obj, types.GeneratorType):
if (attr in UNSAFE_GENERATOR_ATTRIBUTES):
return True
elif (hasattr(types, 'CoroutineType') and isinstance(obj, types.CoroutineType)):
if (attr in UNSAFE_COROUTINE_ATTRIBUTES):
return True
elif (hasattr(types, 'AsyncGeneratorType') and isinstance(obj, types.AsyncGeneratorType)):
if (attr in UNSAFE_ASYNC_GENERATOR_ATTRIBUTES):
return True
return attr.startswith('__')
|
[
"def",
"is_internal_attribute",
"(",
"obj",
",",
"attr",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"types",
".",
"FunctionType",
")",
":",
"if",
"(",
"attr",
"in",
"UNSAFE_FUNCTION_ATTRIBUTES",
")",
":",
"return",
"True",
"elif",
"isinstance",
"(",
"obj",
",",
"types",
".",
"MethodType",
")",
":",
"if",
"(",
"(",
"attr",
"in",
"UNSAFE_FUNCTION_ATTRIBUTES",
")",
"or",
"(",
"attr",
"in",
"UNSAFE_METHOD_ATTRIBUTES",
")",
")",
":",
"return",
"True",
"elif",
"isinstance",
"(",
"obj",
",",
"type",
")",
":",
"if",
"(",
"attr",
"==",
"'mro'",
")",
":",
"return",
"True",
"elif",
"isinstance",
"(",
"obj",
",",
"(",
"types",
".",
"CodeType",
",",
"types",
".",
"TracebackType",
",",
"types",
".",
"FrameType",
")",
")",
":",
"return",
"True",
"elif",
"isinstance",
"(",
"obj",
",",
"types",
".",
"GeneratorType",
")",
":",
"if",
"(",
"attr",
"in",
"UNSAFE_GENERATOR_ATTRIBUTES",
")",
":",
"return",
"True",
"elif",
"(",
"hasattr",
"(",
"types",
",",
"'CoroutineType'",
")",
"and",
"isinstance",
"(",
"obj",
",",
"types",
".",
"CoroutineType",
")",
")",
":",
"if",
"(",
"attr",
"in",
"UNSAFE_COROUTINE_ATTRIBUTES",
")",
":",
"return",
"True",
"elif",
"(",
"hasattr",
"(",
"types",
",",
"'AsyncGeneratorType'",
")",
"and",
"isinstance",
"(",
"obj",
",",
"types",
".",
"AsyncGeneratorType",
")",
")",
":",
"if",
"(",
"attr",
"in",
"UNSAFE_ASYNC_GENERATOR_ATTRIBUTES",
")",
":",
"return",
"True",
"return",
"attr",
".",
"startswith",
"(",
"'__'",
")"
] |
test if the attribute given is an internal python attribute .
|
train
| true
|
13,623
|
def glob(tgt, minion_id=None):
if (minion_id is not None):
if (not isinstance(minion_id, string_types)):
minion_id = str(minion_id)
else:
minion_id = __grains__['id']
matcher = salt.minion.Matcher({'id': minion_id}, __salt__)
try:
return matcher.glob_match(tgt)
except Exception as exc:
log.exception(exc)
return False
|
[
"def",
"glob",
"(",
"tgt",
",",
"minion_id",
"=",
"None",
")",
":",
"if",
"(",
"minion_id",
"is",
"not",
"None",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"minion_id",
",",
"string_types",
")",
")",
":",
"minion_id",
"=",
"str",
"(",
"minion_id",
")",
"else",
":",
"minion_id",
"=",
"__grains__",
"[",
"'id'",
"]",
"matcher",
"=",
"salt",
".",
"minion",
".",
"Matcher",
"(",
"{",
"'id'",
":",
"minion_id",
"}",
",",
"__salt__",
")",
"try",
":",
"return",
"matcher",
".",
"glob_match",
"(",
"tgt",
")",
"except",
"Exception",
"as",
"exc",
":",
"log",
".",
"exception",
"(",
"exc",
")",
"return",
"False"
] |
iterates all filesystem paths that get matched by the glob pattern .
|
train
| false
|
13,624
|
def _all_bookmarks(repo):
return repo.bookmarks()[0]
|
[
"def",
"_all_bookmarks",
"(",
"repo",
")",
":",
"return",
"repo",
".",
"bookmarks",
"(",
")",
"[",
"0",
"]"
] |
returns all bookmarks for the specified repo .
|
train
| false
|
13,625
|
def getSpherical(azimuthDegrees, elevationDegrees, radius=1.0):
return getSphericalByRadians(math.radians(azimuthDegrees), math.radians(elevationDegrees), radius)
|
[
"def",
"getSpherical",
"(",
"azimuthDegrees",
",",
"elevationDegrees",
",",
"radius",
"=",
"1.0",
")",
":",
"return",
"getSphericalByRadians",
"(",
"math",
".",
"radians",
"(",
"azimuthDegrees",
")",
",",
"math",
".",
"radians",
"(",
"elevationDegrees",
")",
",",
"radius",
")"
] |
get the spherical vector3 unit by degrees .
|
train
| false
|
13,626
|
def funcname(func):
if isinstance(func, functools.partial):
return funcname(func.func)
if isinstance(func, methodcaller):
return func.method
module_name = (getattr(func, '__module__', None) or '')
type_name = (getattr(type(func), '__name__', None) or '')
if (('toolz' in module_name) and ('curry' == type_name)):
return func.func_name
if (('multipledispatch' in module_name) and ('Dispatcher' == type_name)):
return func.name
try:
name = func.__name__
if (name == '<lambda>'):
return 'lambda'
return name
except:
return str(func)
|
[
"def",
"funcname",
"(",
"func",
")",
":",
"if",
"isinstance",
"(",
"func",
",",
"functools",
".",
"partial",
")",
":",
"return",
"funcname",
"(",
"func",
".",
"func",
")",
"if",
"isinstance",
"(",
"func",
",",
"methodcaller",
")",
":",
"return",
"func",
".",
"method",
"module_name",
"=",
"(",
"getattr",
"(",
"func",
",",
"'__module__'",
",",
"None",
")",
"or",
"''",
")",
"type_name",
"=",
"(",
"getattr",
"(",
"type",
"(",
"func",
")",
",",
"'__name__'",
",",
"None",
")",
"or",
"''",
")",
"if",
"(",
"(",
"'toolz'",
"in",
"module_name",
")",
"and",
"(",
"'curry'",
"==",
"type_name",
")",
")",
":",
"return",
"func",
".",
"func_name",
"if",
"(",
"(",
"'multipledispatch'",
"in",
"module_name",
")",
"and",
"(",
"'Dispatcher'",
"==",
"type_name",
")",
")",
":",
"return",
"func",
".",
"name",
"try",
":",
"name",
"=",
"func",
".",
"__name__",
"if",
"(",
"name",
"==",
"'<lambda>'",
")",
":",
"return",
"'lambda'",
"return",
"name",
"except",
":",
"return",
"str",
"(",
"func",
")"
] |
get the name of a function .
|
train
| false
|
13,628
|
def uniconvert(s, enc):
if (not isinstance(s, unicode)):
try:
s = bin2unicode(s, enc)
except UnicodeError:
raise UnicodeError(('bad filename: ' + s))
return s.encode(enc)
|
[
"def",
"uniconvert",
"(",
"s",
",",
"enc",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"s",
",",
"unicode",
")",
")",
":",
"try",
":",
"s",
"=",
"bin2unicode",
"(",
"s",
",",
"enc",
")",
"except",
"UnicodeError",
":",
"raise",
"UnicodeError",
"(",
"(",
"'bad filename: '",
"+",
"s",
")",
")",
"return",
"s",
".",
"encode",
"(",
"enc",
")"
] |
convert s to a string containing a unicode sequence encoded using encoding "enc" .
|
train
| false
|
13,629
|
def _step4(state):
C = (state.C == 0).astype(np.int)
covered_C = (C * state.row_uncovered[:, np.newaxis])
covered_C *= astype(state.col_uncovered, dtype=np.int, copy=False)
n = state.C.shape[0]
m = state.C.shape[1]
while True:
(row, col) = np.unravel_index(np.argmax(covered_C), (n, m))
if (covered_C[(row, col)] == 0):
return _step6
else:
state.marked[(row, col)] = 2
star_col = np.argmax((state.marked[row] == 1))
if (not (state.marked[(row, star_col)] == 1)):
state.Z0_r = row
state.Z0_c = col
return _step5
else:
col = star_col
state.row_uncovered[row] = False
state.col_uncovered[col] = True
covered_C[:, col] = (C[:, col] * astype(state.row_uncovered, dtype=np.int, copy=False))
covered_C[row] = 0
|
[
"def",
"_step4",
"(",
"state",
")",
":",
"C",
"=",
"(",
"state",
".",
"C",
"==",
"0",
")",
".",
"astype",
"(",
"np",
".",
"int",
")",
"covered_C",
"=",
"(",
"C",
"*",
"state",
".",
"row_uncovered",
"[",
":",
",",
"np",
".",
"newaxis",
"]",
")",
"covered_C",
"*=",
"astype",
"(",
"state",
".",
"col_uncovered",
",",
"dtype",
"=",
"np",
".",
"int",
",",
"copy",
"=",
"False",
")",
"n",
"=",
"state",
".",
"C",
".",
"shape",
"[",
"0",
"]",
"m",
"=",
"state",
".",
"C",
".",
"shape",
"[",
"1",
"]",
"while",
"True",
":",
"(",
"row",
",",
"col",
")",
"=",
"np",
".",
"unravel_index",
"(",
"np",
".",
"argmax",
"(",
"covered_C",
")",
",",
"(",
"n",
",",
"m",
")",
")",
"if",
"(",
"covered_C",
"[",
"(",
"row",
",",
"col",
")",
"]",
"==",
"0",
")",
":",
"return",
"_step6",
"else",
":",
"state",
".",
"marked",
"[",
"(",
"row",
",",
"col",
")",
"]",
"=",
"2",
"star_col",
"=",
"np",
".",
"argmax",
"(",
"(",
"state",
".",
"marked",
"[",
"row",
"]",
"==",
"1",
")",
")",
"if",
"(",
"not",
"(",
"state",
".",
"marked",
"[",
"(",
"row",
",",
"star_col",
")",
"]",
"==",
"1",
")",
")",
":",
"state",
".",
"Z0_r",
"=",
"row",
"state",
".",
"Z0_c",
"=",
"col",
"return",
"_step5",
"else",
":",
"col",
"=",
"star_col",
"state",
".",
"row_uncovered",
"[",
"row",
"]",
"=",
"False",
"state",
".",
"col_uncovered",
"[",
"col",
"]",
"=",
"True",
"covered_C",
"[",
":",
",",
"col",
"]",
"=",
"(",
"C",
"[",
":",
",",
"col",
"]",
"*",
"astype",
"(",
"state",
".",
"row_uncovered",
",",
"dtype",
"=",
"np",
".",
"int",
",",
"copy",
"=",
"False",
")",
")",
"covered_C",
"[",
"row",
"]",
"=",
"0"
] |
find a noncovered zero and prime it .
|
train
| false
|
13,630
|
def lowercase_keys(mapping):
items = mapping.items()
for (key, value) in items:
del mapping[key]
mapping[key.lower()] = value
|
[
"def",
"lowercase_keys",
"(",
"mapping",
")",
":",
"items",
"=",
"mapping",
".",
"items",
"(",
")",
"for",
"(",
"key",
",",
"value",
")",
"in",
"items",
":",
"del",
"mapping",
"[",
"key",
"]",
"mapping",
"[",
"key",
".",
"lower",
"(",
")",
"]",
"=",
"value"
] |
converts the values of the keys in mapping to lowercase .
|
train
| false
|
13,631
|
def test_import_vispy():
modnames = loaded_vispy_modules('vispy', 2)
assert_equal(modnames, set(_min_modules))
|
[
"def",
"test_import_vispy",
"(",
")",
":",
"modnames",
"=",
"loaded_vispy_modules",
"(",
"'vispy'",
",",
"2",
")",
"assert_equal",
"(",
"modnames",
",",
"set",
"(",
"_min_modules",
")",
")"
] |
importing vispy should only pull in other vispy .
|
train
| false
|
13,632
|
def query_all_issues(after):
page = count(1)
data = []
while True:
page_data = query_issues(next(page), after)
if (not page_data):
break
data.extend(page_data)
return data
|
[
"def",
"query_all_issues",
"(",
"after",
")",
":",
"page",
"=",
"count",
"(",
"1",
")",
"data",
"=",
"[",
"]",
"while",
"True",
":",
"page_data",
"=",
"query_issues",
"(",
"next",
"(",
"page",
")",
",",
"after",
")",
"if",
"(",
"not",
"page_data",
")",
":",
"break",
"data",
".",
"extend",
"(",
"page_data",
")",
"return",
"data"
] |
hits the github api for all closed issues after the given date .
|
train
| true
|
13,633
|
def switch_desc_to_dict(desc):
r = {}
for k in ['mfr_desc', 'hw_desc', 'sw_desc', 'serial_num', 'dp_desc']:
r[k] = getattr(desc, k)
return r
|
[
"def",
"switch_desc_to_dict",
"(",
"desc",
")",
":",
"r",
"=",
"{",
"}",
"for",
"k",
"in",
"[",
"'mfr_desc'",
",",
"'hw_desc'",
",",
"'sw_desc'",
",",
"'serial_num'",
",",
"'dp_desc'",
"]",
":",
"r",
"[",
"k",
"]",
"=",
"getattr",
"(",
"desc",
",",
"k",
")",
"return",
"r"
] |
takes ofp_desc_stats response .
|
train
| false
|
13,634
|
def copy_query_dict(query_dict, attr_list):
res = QueryDict('', mutable=True)
for attr in attr_list:
if query_dict.has_key(attr):
res[attr] = query_dict.get(attr)
return res
|
[
"def",
"copy_query_dict",
"(",
"query_dict",
",",
"attr_list",
")",
":",
"res",
"=",
"QueryDict",
"(",
"''",
",",
"mutable",
"=",
"True",
")",
"for",
"attr",
"in",
"attr_list",
":",
"if",
"query_dict",
".",
"has_key",
"(",
"attr",
")",
":",
"res",
"[",
"attr",
"]",
"=",
"query_dict",
".",
"get",
"(",
"attr",
")",
"return",
"res"
] |
copy_query_dict -> querydict object copy the specified attributes to a new querydict .
|
train
| false
|
13,635
|
def getBackOfLoops(loops):
negativeFloat = (-999999999.7534235)
back = negativeFloat
for loop in loops:
for point in loop:
back = max(back, point.imag)
if (back == negativeFloat):
print 'This should never happen, there are no loops for getBackOfLoops in euclidean'
return back
|
[
"def",
"getBackOfLoops",
"(",
"loops",
")",
":",
"negativeFloat",
"=",
"(",
"-",
"999999999.7534235",
")",
"back",
"=",
"negativeFloat",
"for",
"loop",
"in",
"loops",
":",
"for",
"point",
"in",
"loop",
":",
"back",
"=",
"max",
"(",
"back",
",",
"point",
".",
"imag",
")",
"if",
"(",
"back",
"==",
"negativeFloat",
")",
":",
"print",
"'This should never happen, there are no loops for getBackOfLoops in euclidean'",
"return",
"back"
] |
get the back of the loops .
|
train
| false
|
13,636
|
def set_backend_policy(name, port, policies=None, region=None, key=None, keyid=None, profile=None):
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if (not exists(name, region, key, keyid, profile)):
return True
if (policies is None):
policies = []
try:
conn.set_lb_policies_of_backend_server(name, port, policies)
log.info('Set policies {0} on ELB {1} backend server {2}'.format(policies, name, port))
except boto.exception.BotoServerError as e:
log.debug(e)
log.info('Failed to set policy {0} on ELB {1} backend server {2}: {3}'.format(policies, name, port, e.message))
return False
return True
|
[
"def",
"set_backend_policy",
"(",
"name",
",",
"port",
",",
"policies",
"=",
"None",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
"=",
"region",
",",
"key",
"=",
"key",
",",
"keyid",
"=",
"keyid",
",",
"profile",
"=",
"profile",
")",
"if",
"(",
"not",
"exists",
"(",
"name",
",",
"region",
",",
"key",
",",
"keyid",
",",
"profile",
")",
")",
":",
"return",
"True",
"if",
"(",
"policies",
"is",
"None",
")",
":",
"policies",
"=",
"[",
"]",
"try",
":",
"conn",
".",
"set_lb_policies_of_backend_server",
"(",
"name",
",",
"port",
",",
"policies",
")",
"log",
".",
"info",
"(",
"'Set policies {0} on ELB {1} backend server {2}'",
".",
"format",
"(",
"policies",
",",
"name",
",",
"port",
")",
")",
"except",
"boto",
".",
"exception",
".",
"BotoServerError",
"as",
"e",
":",
"log",
".",
"debug",
"(",
"e",
")",
"log",
".",
"info",
"(",
"'Failed to set policy {0} on ELB {1} backend server {2}: {3}'",
".",
"format",
"(",
"policies",
",",
"name",
",",
"port",
",",
"e",
".",
"message",
")",
")",
"return",
"False",
"return",
"True"
] |
set the policies of an elb backend server .
|
train
| true
|
13,637
|
def averageOnTimePerTimestep(vectors, numSamples=None):
if (vectors.ndim == 1):
vectors.shape = ((-1), 1)
numTimeSteps = len(vectors)
numElements = len(vectors[0])
if (numSamples is not None):
import pdb
pdb.set_trace()
countOn = numpy.random.randint(0, numElements, numSamples)
vectors = vectors[:, countOn]
durations = numpy.zeros(vectors.shape, dtype='int32')
for col in xrange(vectors.shape[1]):
_fillInOnTimes(vectors[:, col], durations[:, col])
sums = vectors.sum(axis=1)
sums.clip(min=1, max=numpy.inf, out=sums)
avgDurations = (durations.sum(axis=1, dtype='float64') / sums)
avgOnTime = (avgDurations.sum() / (avgDurations > 0).sum())
freqCounts = _accumulateFrequencyCounts(avgDurations)
return (avgOnTime, freqCounts)
|
[
"def",
"averageOnTimePerTimestep",
"(",
"vectors",
",",
"numSamples",
"=",
"None",
")",
":",
"if",
"(",
"vectors",
".",
"ndim",
"==",
"1",
")",
":",
"vectors",
".",
"shape",
"=",
"(",
"(",
"-",
"1",
")",
",",
"1",
")",
"numTimeSteps",
"=",
"len",
"(",
"vectors",
")",
"numElements",
"=",
"len",
"(",
"vectors",
"[",
"0",
"]",
")",
"if",
"(",
"numSamples",
"is",
"not",
"None",
")",
":",
"import",
"pdb",
"pdb",
".",
"set_trace",
"(",
")",
"countOn",
"=",
"numpy",
".",
"random",
".",
"randint",
"(",
"0",
",",
"numElements",
",",
"numSamples",
")",
"vectors",
"=",
"vectors",
"[",
":",
",",
"countOn",
"]",
"durations",
"=",
"numpy",
".",
"zeros",
"(",
"vectors",
".",
"shape",
",",
"dtype",
"=",
"'int32'",
")",
"for",
"col",
"in",
"xrange",
"(",
"vectors",
".",
"shape",
"[",
"1",
"]",
")",
":",
"_fillInOnTimes",
"(",
"vectors",
"[",
":",
",",
"col",
"]",
",",
"durations",
"[",
":",
",",
"col",
"]",
")",
"sums",
"=",
"vectors",
".",
"sum",
"(",
"axis",
"=",
"1",
")",
"sums",
".",
"clip",
"(",
"min",
"=",
"1",
",",
"max",
"=",
"numpy",
".",
"inf",
",",
"out",
"=",
"sums",
")",
"avgDurations",
"=",
"(",
"durations",
".",
"sum",
"(",
"axis",
"=",
"1",
",",
"dtype",
"=",
"'float64'",
")",
"/",
"sums",
")",
"avgOnTime",
"=",
"(",
"avgDurations",
".",
"sum",
"(",
")",
"/",
"(",
"avgDurations",
">",
"0",
")",
".",
"sum",
"(",
")",
")",
"freqCounts",
"=",
"_accumulateFrequencyCounts",
"(",
"avgDurations",
")",
"return",
"(",
"avgOnTime",
",",
"freqCounts",
")"
] |
computes the average on-time of the outputs that are on at each time step .
|
train
| true
|
13,638
|
def uniform_linear_layout(points):
indices = numpy.argsort(points)
space = numpy.asarray(linspace(len(points)))
indices = invert_permutation_indices(indices)
points = space[indices]
return points.tolist()
|
[
"def",
"uniform_linear_layout",
"(",
"points",
")",
":",
"indices",
"=",
"numpy",
".",
"argsort",
"(",
"points",
")",
"space",
"=",
"numpy",
".",
"asarray",
"(",
"linspace",
"(",
"len",
"(",
"points",
")",
")",
")",
"indices",
"=",
"invert_permutation_indices",
"(",
"indices",
")",
"points",
"=",
"space",
"[",
"indices",
"]",
"return",
"points",
".",
"tolist",
"(",
")"
] |
layout the points in a uniform linear space while preserving the existing sorting order .
|
train
| false
|
13,639
|
def _KNV0(B, ker_pole, transfer_matrix, j, poles):
transfer_matrix_not_j = np.delete(transfer_matrix, j, axis=1)
(Q, R) = s_qr(transfer_matrix_not_j, mode='full')
mat_ker_pj = np.dot(ker_pole[j], ker_pole[j].T)
yj = np.dot(mat_ker_pj, Q[:, (-1)])
if (not np.allclose(yj, 0)):
xj = (yj / np.linalg.norm(yj))
transfer_matrix[:, j] = xj
|
[
"def",
"_KNV0",
"(",
"B",
",",
"ker_pole",
",",
"transfer_matrix",
",",
"j",
",",
"poles",
")",
":",
"transfer_matrix_not_j",
"=",
"np",
".",
"delete",
"(",
"transfer_matrix",
",",
"j",
",",
"axis",
"=",
"1",
")",
"(",
"Q",
",",
"R",
")",
"=",
"s_qr",
"(",
"transfer_matrix_not_j",
",",
"mode",
"=",
"'full'",
")",
"mat_ker_pj",
"=",
"np",
".",
"dot",
"(",
"ker_pole",
"[",
"j",
"]",
",",
"ker_pole",
"[",
"j",
"]",
".",
"T",
")",
"yj",
"=",
"np",
".",
"dot",
"(",
"mat_ker_pj",
",",
"Q",
"[",
":",
",",
"(",
"-",
"1",
")",
"]",
")",
"if",
"(",
"not",
"np",
".",
"allclose",
"(",
"yj",
",",
"0",
")",
")",
":",
"xj",
"=",
"(",
"yj",
"/",
"np",
".",
"linalg",
".",
"norm",
"(",
"yj",
")",
")",
"transfer_matrix",
"[",
":",
",",
"j",
"]",
"=",
"xj"
] |
algorithm "knv0" kautsky et al .
|
train
| false
|
13,643
|
def get_qualitycheck_list(path_obj):
result = []
checks = get_qualitychecks()
for (check, cat) in checks.items():
result.append({'code': check, 'is_critical': (cat == Category.CRITICAL), 'title': (u'%s' % check_names.get(check, check)), 'url': path_obj.get_translate_url(check=check)})
def alphabetical_critical_first(item):
critical_first = (0 if item['is_critical'] else 1)
return (critical_first, item['title'].lower())
result = sorted(result, key=alphabetical_critical_first)
return result
|
[
"def",
"get_qualitycheck_list",
"(",
"path_obj",
")",
":",
"result",
"=",
"[",
"]",
"checks",
"=",
"get_qualitychecks",
"(",
")",
"for",
"(",
"check",
",",
"cat",
")",
"in",
"checks",
".",
"items",
"(",
")",
":",
"result",
".",
"append",
"(",
"{",
"'code'",
":",
"check",
",",
"'is_critical'",
":",
"(",
"cat",
"==",
"Category",
".",
"CRITICAL",
")",
",",
"'title'",
":",
"(",
"u'%s'",
"%",
"check_names",
".",
"get",
"(",
"check",
",",
"check",
")",
")",
",",
"'url'",
":",
"path_obj",
".",
"get_translate_url",
"(",
"check",
"=",
"check",
")",
"}",
")",
"def",
"alphabetical_critical_first",
"(",
"item",
")",
":",
"critical_first",
"=",
"(",
"0",
"if",
"item",
"[",
"'is_critical'",
"]",
"else",
"1",
")",
"return",
"(",
"critical_first",
",",
"item",
"[",
"'title'",
"]",
".",
"lower",
"(",
")",
")",
"result",
"=",
"sorted",
"(",
"result",
",",
"key",
"=",
"alphabetical_critical_first",
")",
"return",
"result"
] |
returns list of checks sorted in alphabetical order but having critical checks first .
|
train
| false
|
13,645
|
def apply_filters(records, filters):
operators = {COMPARISON.LT: operator.lt, COMPARISON.MAX: operator.le, COMPARISON.EQ: operator.eq, COMPARISON.NOT: operator.ne, COMPARISON.MIN: operator.ge, COMPARISON.GT: operator.gt, COMPARISON.IN: operator.contains, COMPARISON.EXCLUDE: (lambda x, y: (not operator.contains(x, y))), COMPARISON.LIKE: (lambda x, y: re.search(y, x, re.IGNORECASE))}
for record in records:
matches = True
for f in filters:
right = f.value
if (f.field == DEFAULT_ID_FIELD):
if isinstance(right, int):
right = str(right)
left = record
subfields = f.field.split('.')
for subfield in subfields:
if (not isinstance(left, dict)):
break
left = left.get(subfield)
if (f.operator in (COMPARISON.IN, COMPARISON.EXCLUDE)):
(right, left) = (left, right)
elif (left is None):
right_is_number = (isinstance(right, (int, float)) and (right not in (True, False)))
if right_is_number:
matches = False
continue
else:
left = ''
matches = (matches and operators[f.operator](left, right))
if matches:
(yield record)
|
[
"def",
"apply_filters",
"(",
"records",
",",
"filters",
")",
":",
"operators",
"=",
"{",
"COMPARISON",
".",
"LT",
":",
"operator",
".",
"lt",
",",
"COMPARISON",
".",
"MAX",
":",
"operator",
".",
"le",
",",
"COMPARISON",
".",
"EQ",
":",
"operator",
".",
"eq",
",",
"COMPARISON",
".",
"NOT",
":",
"operator",
".",
"ne",
",",
"COMPARISON",
".",
"MIN",
":",
"operator",
".",
"ge",
",",
"COMPARISON",
".",
"GT",
":",
"operator",
".",
"gt",
",",
"COMPARISON",
".",
"IN",
":",
"operator",
".",
"contains",
",",
"COMPARISON",
".",
"EXCLUDE",
":",
"(",
"lambda",
"x",
",",
"y",
":",
"(",
"not",
"operator",
".",
"contains",
"(",
"x",
",",
"y",
")",
")",
")",
",",
"COMPARISON",
".",
"LIKE",
":",
"(",
"lambda",
"x",
",",
"y",
":",
"re",
".",
"search",
"(",
"y",
",",
"x",
",",
"re",
".",
"IGNORECASE",
")",
")",
"}",
"for",
"record",
"in",
"records",
":",
"matches",
"=",
"True",
"for",
"f",
"in",
"filters",
":",
"right",
"=",
"f",
".",
"value",
"if",
"(",
"f",
".",
"field",
"==",
"DEFAULT_ID_FIELD",
")",
":",
"if",
"isinstance",
"(",
"right",
",",
"int",
")",
":",
"right",
"=",
"str",
"(",
"right",
")",
"left",
"=",
"record",
"subfields",
"=",
"f",
".",
"field",
".",
"split",
"(",
"'.'",
")",
"for",
"subfield",
"in",
"subfields",
":",
"if",
"(",
"not",
"isinstance",
"(",
"left",
",",
"dict",
")",
")",
":",
"break",
"left",
"=",
"left",
".",
"get",
"(",
"subfield",
")",
"if",
"(",
"f",
".",
"operator",
"in",
"(",
"COMPARISON",
".",
"IN",
",",
"COMPARISON",
".",
"EXCLUDE",
")",
")",
":",
"(",
"right",
",",
"left",
")",
"=",
"(",
"left",
",",
"right",
")",
"elif",
"(",
"left",
"is",
"None",
")",
":",
"right_is_number",
"=",
"(",
"isinstance",
"(",
"right",
",",
"(",
"int",
",",
"float",
")",
")",
"and",
"(",
"right",
"not",
"in",
"(",
"True",
",",
"False",
")",
")",
")",
"if",
"right_is_number",
":",
"matches",
"=",
"False",
"continue",
"else",
":",
"left",
"=",
"''",
"matches",
"=",
"(",
"matches",
"and",
"operators",
"[",
"f",
".",
"operator",
"]",
"(",
"left",
",",
"right",
")",
")",
"if",
"matches",
":",
"(",
"yield",
"record",
")"
] |
use this method to apply an iterable of filters to a stream .
|
train
| false
|
13,646
|
def nathanathan(function, yays=[], nays=[]):
yay_set = set()
nay_set = set()
for yay in yays:
if (yay in yay_set):
print (yay + ' tried to vote more than once.')
else:
yay_set.add(yay)
for nay in nays:
if (nay in nay_set):
print (nay + ' tried to vote more than once.')
else:
nay_set.add(nay)
for yay_nay_vote in yay_set.intersection(nay_set):
print (yay_nay_vote + ' voted yay and nay.')
valid_names = nathanathan.__globals__.keys()
for vote in yay_set.union(nay_set):
if (vote not in valid_names):
print (vote + ' is not a valid voter')
if (vote in yay_set):
yay_set.remove(vote)
if (vote in nay_set):
nay_set.remove(vote)
if (len(yay_set) >= len(nay_set)):
function()
|
[
"def",
"nathanathan",
"(",
"function",
",",
"yays",
"=",
"[",
"]",
",",
"nays",
"=",
"[",
"]",
")",
":",
"yay_set",
"=",
"set",
"(",
")",
"nay_set",
"=",
"set",
"(",
")",
"for",
"yay",
"in",
"yays",
":",
"if",
"(",
"yay",
"in",
"yay_set",
")",
":",
"print",
"(",
"yay",
"+",
"' tried to vote more than once.'",
")",
"else",
":",
"yay_set",
".",
"add",
"(",
"yay",
")",
"for",
"nay",
"in",
"nays",
":",
"if",
"(",
"nay",
"in",
"nay_set",
")",
":",
"print",
"(",
"nay",
"+",
"' tried to vote more than once.'",
")",
"else",
":",
"nay_set",
".",
"add",
"(",
"nay",
")",
"for",
"yay_nay_vote",
"in",
"yay_set",
".",
"intersection",
"(",
"nay_set",
")",
":",
"print",
"(",
"yay_nay_vote",
"+",
"' voted yay and nay.'",
")",
"valid_names",
"=",
"nathanathan",
".",
"__globals__",
".",
"keys",
"(",
")",
"for",
"vote",
"in",
"yay_set",
".",
"union",
"(",
"nay_set",
")",
":",
"if",
"(",
"vote",
"not",
"in",
"valid_names",
")",
":",
"print",
"(",
"vote",
"+",
"' is not a valid voter'",
")",
"if",
"(",
"vote",
"in",
"yay_set",
")",
":",
"yay_set",
".",
"remove",
"(",
"vote",
")",
"if",
"(",
"vote",
"in",
"nay_set",
")",
":",
"nay_set",
".",
"remove",
"(",
"vote",
")",
"if",
"(",
"len",
"(",
"yay_set",
")",
">=",
"len",
"(",
"nay_set",
")",
")",
":",
"function",
"(",
")"
] |
this is a function for voting on whether functions should run .
|
train
| false
|
13,647
|
def label_indivs(valuation, lexicon=False):
domain = valuation.domain
pairs = [(e, e) for e in domain]
if lexicon:
lex = make_lex(domain)
with open(u'chat_pnames.cfg', u'w') as outfile:
outfile.writelines(lex)
valuation.update(pairs)
return valuation
|
[
"def",
"label_indivs",
"(",
"valuation",
",",
"lexicon",
"=",
"False",
")",
":",
"domain",
"=",
"valuation",
".",
"domain",
"pairs",
"=",
"[",
"(",
"e",
",",
"e",
")",
"for",
"e",
"in",
"domain",
"]",
"if",
"lexicon",
":",
"lex",
"=",
"make_lex",
"(",
"domain",
")",
"with",
"open",
"(",
"u'chat_pnames.cfg'",
",",
"u'w'",
")",
"as",
"outfile",
":",
"outfile",
".",
"writelines",
"(",
"lex",
")",
"valuation",
".",
"update",
"(",
"pairs",
")",
"return",
"valuation"
] |
assign individual constants to the individuals in the domain of a valuation .
|
train
| false
|
13,649
|
def sub_func_doit(eq, func, new):
reps = {}
repu = {}
for d in eq.atoms(Derivative):
u = Dummy('u')
repu[u] = d.subs(func, new).doit()
reps[d] = u
return eq.subs(reps).subs(func, new).subs(repu)
|
[
"def",
"sub_func_doit",
"(",
"eq",
",",
"func",
",",
"new",
")",
":",
"reps",
"=",
"{",
"}",
"repu",
"=",
"{",
"}",
"for",
"d",
"in",
"eq",
".",
"atoms",
"(",
"Derivative",
")",
":",
"u",
"=",
"Dummy",
"(",
"'u'",
")",
"repu",
"[",
"u",
"]",
"=",
"d",
".",
"subs",
"(",
"func",
",",
"new",
")",
".",
"doit",
"(",
")",
"reps",
"[",
"d",
"]",
"=",
"u",
"return",
"eq",
".",
"subs",
"(",
"reps",
")",
".",
"subs",
"(",
"func",
",",
"new",
")",
".",
"subs",
"(",
"repu",
")"
] |
when replacing the func with something else .
|
train
| false
|
13,650
|
def tee(content, file):
fd = open(file, 'a')
fd.write((content + '\n'))
fd.close()
print content
|
[
"def",
"tee",
"(",
"content",
",",
"file",
")",
":",
"fd",
"=",
"open",
"(",
"file",
",",
"'a'",
")",
"fd",
".",
"write",
"(",
"(",
"content",
"+",
"'\\n'",
")",
")",
"fd",
".",
"close",
"(",
")",
"print",
"content"
] |
write content to standard output and file .
|
train
| false
|
13,652
|
def wrap_old_error_serializer(old_fn):
def new_fn(req, resp, exception):
(media_type, body) = old_fn(req, exception)
if (body is not None):
resp.body = body
resp.content_type = media_type
return new_fn
|
[
"def",
"wrap_old_error_serializer",
"(",
"old_fn",
")",
":",
"def",
"new_fn",
"(",
"req",
",",
"resp",
",",
"exception",
")",
":",
"(",
"media_type",
",",
"body",
")",
"=",
"old_fn",
"(",
"req",
",",
"exception",
")",
"if",
"(",
"body",
"is",
"not",
"None",
")",
":",
"resp",
".",
"body",
"=",
"body",
"resp",
".",
"content_type",
"=",
"media_type",
"return",
"new_fn"
] |
wraps an old-style error serializer to add body/content_type setting .
|
train
| false
|
13,653
|
@ensure_csrf_cookie
@cache_if_anonymous()
def courses(request):
enable_mktg_site = configuration_helpers.get_value('ENABLE_MKTG_SITE', settings.FEATURES.get('ENABLE_MKTG_SITE', False))
if enable_mktg_site:
return redirect(marketing_link('COURSES'), permanent=True)
if (not settings.FEATURES.get('COURSES_ARE_BROWSABLE')):
raise Http404
return courseware.views.views.courses(request)
|
[
"@",
"ensure_csrf_cookie",
"@",
"cache_if_anonymous",
"(",
")",
"def",
"courses",
"(",
"request",
")",
":",
"enable_mktg_site",
"=",
"configuration_helpers",
".",
"get_value",
"(",
"'ENABLE_MKTG_SITE'",
",",
"settings",
".",
"FEATURES",
".",
"get",
"(",
"'ENABLE_MKTG_SITE'",
",",
"False",
")",
")",
"if",
"enable_mktg_site",
":",
"return",
"redirect",
"(",
"marketing_link",
"(",
"'COURSES'",
")",
",",
"permanent",
"=",
"True",
")",
"if",
"(",
"not",
"settings",
".",
"FEATURES",
".",
"get",
"(",
"'COURSES_ARE_BROWSABLE'",
")",
")",
":",
"raise",
"Http404",
"return",
"courseware",
".",
"views",
".",
"views",
".",
"courses",
"(",
"request",
")"
] |
render the "find courses" page .
|
train
| false
|
13,654
|
def standard_node(hostname):
return ProcessNode.using_ssh(hostname, 22, 'root', SSH_PRIVATE_KEY_PATH)
|
[
"def",
"standard_node",
"(",
"hostname",
")",
":",
"return",
"ProcessNode",
".",
"using_ssh",
"(",
"hostname",
",",
"22",
",",
"'root'",
",",
"SSH_PRIVATE_KEY_PATH",
")"
] |
create the default production inode for the given hostname .
|
train
| false
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.