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 |
|---|---|---|---|---|---|
50,055 | def rolling_count(arg, window, **kwargs):
return ensure_compat('rolling', 'count', arg, window=window, **kwargs)
| [
"def",
"rolling_count",
"(",
"arg",
",",
"window",
",",
"**",
"kwargs",
")",
":",
"return",
"ensure_compat",
"(",
"'rolling'",
",",
"'count'",
",",
"arg",
",",
"window",
"=",
"window",
",",
"**",
"kwargs",
")"
] | rolling count of number of non-nan observations inside provided window . | train | false |
50,056 | def buildSimpleBorderSwipingNet(size=3, dim=3, hsize=1, predefined={}):
dims = tuple(([size] * dim))
hdims = tuple((list(dims) + [(2 ** dim)]))
inmod = LinearLayer((size ** dim), name='input')
inmesh = ModuleMesh.viewOnFlatLayer(inmod, dims, 'inmesh')
outmod = LinearLayer((size ** dim), name='output')
outmesh = ModuleMesh.viewOnFlatLayer(outmod, dims, 'outmesh')
hiddenmesh = ModuleMesh.constructWithLayers(TanhLayer, hsize, hdims, 'hidden')
return BorderSwipingNetwork(inmesh, hiddenmesh, outmesh, predefined=predefined)
| [
"def",
"buildSimpleBorderSwipingNet",
"(",
"size",
"=",
"3",
",",
"dim",
"=",
"3",
",",
"hsize",
"=",
"1",
",",
"predefined",
"=",
"{",
"}",
")",
":",
"dims",
"=",
"tuple",
"(",
"(",
"[",
"size",
"]",
"*",
"dim",
")",
")",
"hdims",
"=",
"tuple",
... | build a simple swiping network . | train | false |
50,057 | def tag_source(source_name, tag_names=None):
if ((not tag_names) or (tag_names is None)):
return
session = Session()
try:
source = session.query(ArchiveSource).filter((ArchiveSource.name == source_name)).first()
if (not source):
log.critical((u'Source `%s` does not exists' % source_name))
srcs = u', '.join([s.name for s in session.query(ArchiveSource).order_by(ArchiveSource.name)])
if srcs:
log.info((u'Known sources: %s' % srcs))
return
tags = []
for tag_name in tag_names:
tags.append(get_tag(tag_name, session))
log.verbose((u'Please wait while adding tags %s ...' % u', '.join(tag_names)))
for a in session.query(ArchiveEntry).filter(ArchiveEntry.sources.any(name=source_name)).yield_per(5):
a.tags.extend(tags)
finally:
session.commit()
session.close()
| [
"def",
"tag_source",
"(",
"source_name",
",",
"tag_names",
"=",
"None",
")",
":",
"if",
"(",
"(",
"not",
"tag_names",
")",
"or",
"(",
"tag_names",
"is",
"None",
")",
")",
":",
"return",
"session",
"=",
"Session",
"(",
")",
"try",
":",
"source",
"=",
... | tags all archived entries within a source with supplied tags . | train | false |
50,058 | def _make_faces_from_pb(faces):
return [Face.from_pb(face) for face in faces]
| [
"def",
"_make_faces_from_pb",
"(",
"faces",
")",
":",
"return",
"[",
"Face",
".",
"from_pb",
"(",
"face",
")",
"for",
"face",
"in",
"faces",
"]"
] | create face objects from a protobuf response . | train | false |
50,062 | def _rcm_estimate(G, nodelist):
G = G.subgraph(nodelist)
order = reverse_cuthill_mckee_ordering(G)
n = len(nodelist)
index = dict(zip(nodelist, range(n)))
x = ndarray(n, dtype=float)
for (i, u) in enumerate(order):
x[index[u]] = i
x -= ((n - 1) / 2.0)
return x
| [
"def",
"_rcm_estimate",
"(",
"G",
",",
"nodelist",
")",
":",
"G",
"=",
"G",
".",
"subgraph",
"(",
"nodelist",
")",
"order",
"=",
"reverse_cuthill_mckee_ordering",
"(",
"G",
")",
"n",
"=",
"len",
"(",
"nodelist",
")",
"index",
"=",
"dict",
"(",
"zip",
... | estimate the fiedler vector using the reverse cuthill-mckee ordering . | train | false |
50,063 | def _get_configdir():
return _get_config_or_cache_dir(_get_xdg_config_dir())
| [
"def",
"_get_configdir",
"(",
")",
":",
"return",
"_get_config_or_cache_dir",
"(",
"_get_xdg_config_dir",
"(",
")",
")"
] | return the string representing the configuration directory . | train | false |
50,064 | def draw_circular(G, **kwargs):
draw(G, circular_layout(G), **kwargs)
| [
"def",
"draw_circular",
"(",
"G",
",",
"**",
"kwargs",
")",
":",
"draw",
"(",
"G",
",",
"circular_layout",
"(",
"G",
")",
",",
"**",
"kwargs",
")"
] | draw the graph g with a circular layout . | train | false |
50,065 | def merge_delete(del_chunks, doc):
doc.append(DEL_START)
doc.extend(del_chunks)
doc.append(DEL_END)
| [
"def",
"merge_delete",
"(",
"del_chunks",
",",
"doc",
")",
":",
"doc",
".",
"append",
"(",
"DEL_START",
")",
"doc",
".",
"extend",
"(",
"del_chunks",
")",
"doc",
".",
"append",
"(",
"DEL_END",
")"
] | adds the text chunks in del_chunks to the document doc with marker to show it is a delete . | train | true |
50,068 | @register.filter(is_safe=True)
@stringfilter
def truncatechars_html(value, arg):
try:
length = int(arg)
except ValueError:
return value
return Truncator(value).chars(length, html=True)
| [
"@",
"register",
".",
"filter",
"(",
"is_safe",
"=",
"True",
")",
"@",
"stringfilter",
"def",
"truncatechars_html",
"(",
"value",
",",
"arg",
")",
":",
"try",
":",
"length",
"=",
"int",
"(",
"arg",
")",
"except",
"ValueError",
":",
"return",
"value",
"... | truncates html after a certain number of chars . | train | false |
50,069 | def warn_default(version):
if (config.warn.ignore_bug_before == 'None'):
return True
if (config.warn.ignore_bug_before == 'all'):
return False
if (config.warn.ignore_bug_before >= version):
return False
return True
| [
"def",
"warn_default",
"(",
"version",
")",
":",
"if",
"(",
"config",
".",
"warn",
".",
"ignore_bug_before",
"==",
"'None'",
")",
":",
"return",
"True",
"if",
"(",
"config",
".",
"warn",
".",
"ignore_bug_before",
"==",
"'all'",
")",
":",
"return",
"False... | return true iff we should warn about bugs fixed after a given version . | train | false |
50,070 | def utc_millesecs_from_epoch(for_datetime=None):
if (not for_datetime):
for_datetime = datetime.datetime.now()
return (calendar.timegm(for_datetime.utctimetuple()) * 1000)
| [
"def",
"utc_millesecs_from_epoch",
"(",
"for_datetime",
"=",
"None",
")",
":",
"if",
"(",
"not",
"for_datetime",
")",
":",
"for_datetime",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
"return",
"(",
"calendar",
".",
"timegm",
"(",
"for_datetime",
... | returns millesconds from the unix epoch in utc . | train | false |
50,072 | def clone_request(request, method):
ret = Request(request=request._request, parsers=request.parsers, authenticators=request.authenticators, negotiator=request.negotiator, parser_context=request.parser_context)
ret._data = request._data
ret._files = request._files
ret._content_type = request._content_type
ret._stream = request._stream
ret._method = method
if hasattr(request, '_user'):
ret._user = request._user
if hasattr(request, '_auth'):
ret._auth = request._auth
if hasattr(request, '_authenticator'):
ret._authenticator = request._authenticator
return ret
| [
"def",
"clone_request",
"(",
"request",
",",
"method",
")",
":",
"ret",
"=",
"Request",
"(",
"request",
"=",
"request",
".",
"_request",
",",
"parsers",
"=",
"request",
".",
"parsers",
",",
"authenticators",
"=",
"request",
".",
"authenticators",
",",
"neg... | internal helper method to clone a request . | train | false |
50,073 | def _set_tcp_keepalive(zmq_socket, opts):
if (hasattr(zmq, 'TCP_KEEPALIVE') and opts):
if ('tcp_keepalive' in opts):
zmq_socket.setsockopt(zmq.TCP_KEEPALIVE, opts['tcp_keepalive'])
if ('tcp_keepalive_idle' in opts):
zmq_socket.setsockopt(zmq.TCP_KEEPALIVE_IDLE, opts['tcp_keepalive_idle'])
if ('tcp_keepalive_cnt' in opts):
zmq_socket.setsockopt(zmq.TCP_KEEPALIVE_CNT, opts['tcp_keepalive_cnt'])
if ('tcp_keepalive_intvl' in opts):
zmq_socket.setsockopt(zmq.TCP_KEEPALIVE_INTVL, opts['tcp_keepalive_intvl'])
| [
"def",
"_set_tcp_keepalive",
"(",
"zmq_socket",
",",
"opts",
")",
":",
"if",
"(",
"hasattr",
"(",
"zmq",
",",
"'TCP_KEEPALIVE'",
")",
"and",
"opts",
")",
":",
"if",
"(",
"'tcp_keepalive'",
"in",
"opts",
")",
":",
"zmq_socket",
".",
"setsockopt",
"(",
"zm... | ensure that tcp keepalives are set as specified in "opts" . | train | true |
50,074 | def DistEntry():
flags.StartMain(main)
| [
"def",
"DistEntry",
"(",
")",
":",
"flags",
".",
"StartMain",
"(",
"main",
")"
] | the main entry point for packages . | train | false |
50,075 | def get_site_user(context, data_dict):
_check_access('get_site_user', context, data_dict)
model = context['model']
site_id = config.get('ckan.site_id', 'ckan_site_user')
user = model.User.get(site_id)
if (not user):
apikey = str(uuid.uuid4())
user = model.User(name=site_id, password=apikey, apikey=apikey)
user.sysadmin = True
model.Session.add(user)
model.Session.flush()
if (not context.get('defer_commit')):
model.repo.commit()
return {'name': user.name, 'apikey': user.apikey}
| [
"def",
"get_site_user",
"(",
"context",
",",
"data_dict",
")",
":",
"_check_access",
"(",
"'get_site_user'",
",",
"context",
",",
"data_dict",
")",
"model",
"=",
"context",
"[",
"'model'",
"]",
"site_id",
"=",
"config",
".",
"get",
"(",
"'ckan.site_id'",
","... | return the ckan site user . | train | false |
50,076 | def enforce_limit(limit):
if (limit is None):
limit = pecan.request.cfg.api.default_api_return_limit
LOG.info(_LI('No limit value provided, result set will be limited to %(limit)d.'), {'limit': limit})
if ((not limit) or (limit <= 0)):
raise base.ClientSideError(_('Limit must be positive'))
return limit
| [
"def",
"enforce_limit",
"(",
"limit",
")",
":",
"if",
"(",
"limit",
"is",
"None",
")",
":",
"limit",
"=",
"pecan",
".",
"request",
".",
"cfg",
".",
"api",
".",
"default_api_return_limit",
"LOG",
".",
"info",
"(",
"_LI",
"(",
"'No limit value provided, resu... | ensure limit is defined and is valid . | train | false |
50,077 | def typecheck(expressions, signature=None):
for expression in expressions:
signature = expression.typecheck(signature)
for expression in expressions[:(-1)]:
expression.typecheck(signature)
return signature
| [
"def",
"typecheck",
"(",
"expressions",
",",
"signature",
"=",
"None",
")",
":",
"for",
"expression",
"in",
"expressions",
":",
"signature",
"=",
"expression",
".",
"typecheck",
"(",
"signature",
")",
"for",
"expression",
"in",
"expressions",
"[",
":",
"(",
... | ensure correct typing across a collection of expression objects . | train | false |
50,078 | def _iterate_axial_slices(array, limits=None):
shape = array.shape[1]
for ind in range(shape):
if (limits and (ind not in limits)):
continue
(yield (ind, array[:, ind, :]))
| [
"def",
"_iterate_axial_slices",
"(",
"array",
",",
"limits",
"=",
"None",
")",
":",
"shape",
"=",
"array",
".",
"shape",
"[",
"1",
"]",
"for",
"ind",
"in",
"range",
"(",
"shape",
")",
":",
"if",
"(",
"limits",
"and",
"(",
"ind",
"not",
"in",
"limit... | iterate axial slices . | train | false |
50,079 | def house_graph(create_using=None):
description = ['adjacencylist', 'House Graph', 5, [[2, 3], [1, 4], [1, 4, 5], [2, 3, 5], [3, 4]]]
G = make_small_undirected_graph(description, create_using)
return G
| [
"def",
"house_graph",
"(",
"create_using",
"=",
"None",
")",
":",
"description",
"=",
"[",
"'adjacencylist'",
",",
"'House Graph'",
",",
"5",
",",
"[",
"[",
"2",
",",
"3",
"]",
",",
"[",
"1",
",",
"4",
"]",
",",
"[",
"1",
",",
"4",
",",
"5",
"]... | return the house graph . | train | false |
50,080 | def create_dir(path):
try:
os.makedirs(path)
except OSError as exception:
if (exception.errno != errno.EEXIST):
raise
| [
"def",
"create_dir",
"(",
"path",
")",
":",
"try",
":",
"os",
".",
"makedirs",
"(",
"path",
")",
"except",
"OSError",
"as",
"exception",
":",
"if",
"(",
"exception",
".",
"errno",
"!=",
"errno",
".",
"EEXIST",
")",
":",
"raise"
] | creates a directory atomically . | train | false |
50,081 | def view_as_blocks(arr_in, block_shape):
if (not isinstance(block_shape, tuple)):
raise TypeError('block needs to be a tuple')
block_shape = np.array(block_shape)
if (block_shape <= 0).any():
raise ValueError("'block_shape' elements must be strictly positive")
if (block_shape.size != arr_in.ndim):
raise ValueError("'block_shape' must have the same length as 'arr_in.shape'")
arr_shape = np.array(arr_in.shape)
if ((arr_shape % block_shape).sum() != 0):
raise ValueError("'block_shape' is not compatible with 'arr_in'")
if (not arr_in.flags.contiguous):
warn(RuntimeWarning('Cannot provide views on a non-contiguous input array without copying.'))
arr_in = np.ascontiguousarray(arr_in)
new_shape = (tuple((arr_shape // block_shape)) + tuple(block_shape))
new_strides = (tuple((arr_in.strides * block_shape)) + arr_in.strides)
arr_out = as_strided(arr_in, shape=new_shape, strides=new_strides)
return arr_out
| [
"def",
"view_as_blocks",
"(",
"arr_in",
",",
"block_shape",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"block_shape",
",",
"tuple",
")",
")",
":",
"raise",
"TypeError",
"(",
"'block needs to be a tuple'",
")",
"block_shape",
"=",
"np",
".",
"array",
"(",... | block view of the input n-dimensional array . | train | false |
50,083 | def process_movie_reviews(service, reader, sentiment_writer, entity_writer):
collected_entities = {}
for document in reader:
try:
(sentiment_total, entities) = get_sentiment_entities(service, document)
except HttpError as e:
logging.error('Error process_movie_reviews {}'.format(e.content))
continue
document.label = get_sentiment_label(sentiment_total)
sentiment_writer.write(to_sentiment_json(document.doc_id, sentiment_total, document.label))
sentiment_writer.write('\n')
for ent in entities:
(ent_sent, frequency) = collected_entities.get(ent, (0, 0))
ent_sent += sentiment_total
frequency += 1
collected_entities[ent] = (ent_sent, frequency)
for (entity, sentiment_frequency) in collected_entities.items():
entity_writer.write(to_entity_json(entity, sentiment_frequency[0], sentiment_frequency[1]))
entity_writer.write('\n')
sentiment_writer.flush()
entity_writer.flush()
| [
"def",
"process_movie_reviews",
"(",
"service",
",",
"reader",
",",
"sentiment_writer",
",",
"entity_writer",
")",
":",
"collected_entities",
"=",
"{",
"}",
"for",
"document",
"in",
"reader",
":",
"try",
":",
"(",
"sentiment_total",
",",
"entities",
")",
"=",
... | perform some sentiment math and come up with movie review . | train | false |
50,084 | def smoment(X, n, condition=None, **kwargs):
sigma = std(X, condition, **kwargs)
return (((1 / sigma) ** n) * cmoment(X, n, condition, **kwargs))
| [
"def",
"smoment",
"(",
"X",
",",
"n",
",",
"condition",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"sigma",
"=",
"std",
"(",
"X",
",",
"condition",
",",
"**",
"kwargs",
")",
"return",
"(",
"(",
"(",
"1",
"/",
"sigma",
")",
"**",
"n",
")",
"*... | return the nth standardized moment of a random expression i . | train | false |
50,085 | def hash_shard(word):
return ('server%d' % (hash(word) % 4))
| [
"def",
"hash_shard",
"(",
"word",
")",
":",
"return",
"(",
"'server%d'",
"%",
"(",
"hash",
"(",
"word",
")",
"%",
"4",
")",
")"
] | assign data to servers using pythons built-in hash() function . | train | false |
50,089 | def PackBool(name, value, pbvalue):
pbvalue.set_booleanvalue(value)
| [
"def",
"PackBool",
"(",
"name",
",",
"value",
",",
"pbvalue",
")",
":",
"pbvalue",
".",
"set_booleanvalue",
"(",
"value",
")"
] | packs a boolean property into a entity_pb . | train | false |
50,091 | def check_missing_generic(role, folder_base, generic_role_names, provider, constants, monkeypatch):
assert (folder_base is not None)
role_map = (constants['gmail_role_map'] if (provider == 'gmail') else constants['imap_role_map'])
keys_to_remove = []
for folder_name in role_map:
if (role_map[folder_name] == role):
keys_to_remove.append(folder_name)
for key in keys_to_remove:
del role_map[key]
for role_alias in generic_role_names:
folders = (folder_base + [('\\HasNoChildren', '/', role_alias)])
client = (patch_gmail_client(monkeypatch, folders) if (provider == 'gmail') else patch_generic_client(monkeypatch, folders))
raw_folders = client.folders()
role_map[role_alias] = role
generic_folder_checks(raw_folders, role_map, client, provider)
del role_map[role_alias]
| [
"def",
"check_missing_generic",
"(",
"role",
",",
"folder_base",
",",
"generic_role_names",
",",
"provider",
",",
"constants",
",",
"monkeypatch",
")",
":",
"assert",
"(",
"folder_base",
"is",
"not",
"None",
")",
"role_map",
"=",
"(",
"constants",
"[",
"'gmail... | check clients label every folder in generic_role_names as input role role: the role that the generic_role_names should be assigned folder_base: generic list of folders . | train | false |
50,093 | def Handle(environ):
error = logservice.LogsBuffer()
request_environment.current_request.Init(error, environ)
response = {'error': 0, 'response_code': 200}
try:
request_id = environ[BACKGROUND_REQUEST_ID]
_pending_background_threads.RunBackgroundThread(request_id)
return response
except:
exception = sys.exc_info()
tb = exception[2].tb_next
if tb:
tb = tb.tb_next
message = ''.join(traceback.format_exception(exception[0], exception[1], tb))
logging.error(message)
response['response_code'] = 500
response['error'] = 1
return response
finally:
request_environment.current_request.Clear()
response['logs'] = error.parse_logs()
| [
"def",
"Handle",
"(",
"environ",
")",
":",
"error",
"=",
"logservice",
".",
"LogsBuffer",
"(",
")",
"request_environment",
".",
"current_request",
".",
"Init",
"(",
"error",
",",
"environ",
")",
"response",
"=",
"{",
"'error'",
":",
"0",
",",
"'response_co... | handles a background request . | train | false |
50,095 | def getTextComplexLoops(fontFamily, fontSize, text, yAxisPointingUpward=True):
textComplexLoops = []
fontReader = getFontReader(fontFamily)
horizontalAdvanceX = 0.0
for character in text:
glyph = fontReader.getGlyph(character, yAxisPointingUpward)
textComplexLoops += glyph.getSizedAdvancedLoops(fontSize, horizontalAdvanceX, yAxisPointingUpward)
horizontalAdvanceX += glyph.horizontalAdvanceX
return textComplexLoops
| [
"def",
"getTextComplexLoops",
"(",
"fontFamily",
",",
"fontSize",
",",
"text",
",",
"yAxisPointingUpward",
"=",
"True",
")",
":",
"textComplexLoops",
"=",
"[",
"]",
"fontReader",
"=",
"getFontReader",
"(",
"fontFamily",
")",
"horizontalAdvanceX",
"=",
"0.0",
"fo... | get text as complex loops . | train | false |
50,098 | def _gather_update_categories(updateCollection):
categories = []
for i in range(updateCollection.Count):
update = updateCollection.Item(i)
for j in range(update.Categories.Count):
name = update.Categories.Item(j).Name
if (name not in categories):
log.debug('found category: {0}'.format(name))
categories.append(name)
return categories
| [
"def",
"_gather_update_categories",
"(",
"updateCollection",
")",
":",
"categories",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"updateCollection",
".",
"Count",
")",
":",
"update",
"=",
"updateCollection",
".",
"Item",
"(",
"i",
")",
"for",
"j",
"in",... | this is a convenience method to gather what categories of updates are available in any update collection it is passed . | train | false |
50,099 | def check_versions(service, versions, required, recommended=None):
must_upgrade = dict(filter((lambda x: (required > x[1])), versions.items()))
if must_upgrade:
raise InvalidConfiguration(make_upgrade_message(service, 'must', required, must_upgrade))
if recommended:
should_upgrade = dict(filter((lambda x: (recommended > x[1])), versions.items()))
if should_upgrade:
warnings.warn(make_upgrade_message(service, 'should', recommended, should_upgrade), PendingDeprecationWarning)
| [
"def",
"check_versions",
"(",
"service",
",",
"versions",
",",
"required",
",",
"recommended",
"=",
"None",
")",
":",
"must_upgrade",
"=",
"dict",
"(",
"filter",
"(",
"(",
"lambda",
"x",
":",
"(",
"required",
">",
"x",
"[",
"1",
"]",
")",
")",
",",
... | check that hosts fulfill version requirements . | train | false |
50,100 | def test_fnpickling_simple(tmpdir):
fn = str(tmpdir.join('test1.pickle'))
obj1 = 'astring'
fnpickle(obj1, fn)
res = fnunpickle(fn)
assert (obj1 == res)
fnpickle(obj1, fn, usecPickle=False)
res = fnunpickle(fn, usecPickle=False)
assert (obj1 == res)
with open(fn, 'wb') as f:
fnpickle(obj1, f)
with open(fn, 'rb') as f:
res = fnunpickle(f)
assert (obj1 == res)
with open(fn, 'wb') as f:
fnpickle(obj1, f, usecPickle=False)
with open(fn, 'rb') as f:
res = fnunpickle(f, usecPickle=False)
assert (obj1 == res)
| [
"def",
"test_fnpickling_simple",
"(",
"tmpdir",
")",
":",
"fn",
"=",
"str",
"(",
"tmpdir",
".",
"join",
"(",
"'test1.pickle'",
")",
")",
"obj1",
"=",
"'astring'",
"fnpickle",
"(",
"obj1",
",",
"fn",
")",
"res",
"=",
"fnunpickle",
"(",
"fn",
")",
"asser... | tests the fnpickle and fnupickle functions basic operation by pickling and unpickling a string . | train | false |
50,102 | def cleanUp(*arg, **kw):
package = kw.get('package', None)
if (package is None):
package = caller_package()
kw['package'] = package
return setUp(*arg, **kw)
| [
"def",
"cleanUp",
"(",
"*",
"arg",
",",
"**",
"kw",
")",
":",
"package",
"=",
"kw",
".",
"get",
"(",
"'package'",
",",
"None",
")",
"if",
"(",
"package",
"is",
"None",
")",
":",
"package",
"=",
"caller_package",
"(",
")",
"kw",
"[",
"'package'",
... | just removes the dlls directory we created . | train | false |
50,103 | def _prep_tuple(v):
from sympy import unpolarify
return TupleArg(*[unpolarify(x) for x in v])
| [
"def",
"_prep_tuple",
"(",
"v",
")",
":",
"from",
"sympy",
"import",
"unpolarify",
"return",
"TupleArg",
"(",
"*",
"[",
"unpolarify",
"(",
"x",
")",
"for",
"x",
"in",
"v",
"]",
")"
] | turn an iterable argument v into a tuple and unpolarify . | train | false |
50,104 | def _make_lock_uri(cloud_tmp_dir, cluster_id, step_num):
return ((((cloud_tmp_dir + 'locks/') + cluster_id) + '/') + str(step_num))
| [
"def",
"_make_lock_uri",
"(",
"cloud_tmp_dir",
",",
"cluster_id",
",",
"step_num",
")",
":",
"return",
"(",
"(",
"(",
"(",
"cloud_tmp_dir",
"+",
"'locks/'",
")",
"+",
"cluster_id",
")",
"+",
"'/'",
")",
"+",
"str",
"(",
"step_num",
")",
")"
] | generate the uri to lock the cluster cluster_id . | train | false |
50,105 | def connectionCreatorFromEndpoint(memoryReactor, tlsEndpoint):
return tlsEndpoint._wrapperFactory(None)._connectionCreator
| [
"def",
"connectionCreatorFromEndpoint",
"(",
"memoryReactor",
",",
"tlsEndpoint",
")",
":",
"return",
"tlsEndpoint",
".",
"_wrapperFactory",
"(",
"None",
")",
".",
"_connectionCreator"
] | given a l{memoryreactor} and the result of calling l{wrapclienttls} . | train | false |
50,106 | def env(*args, **kwargs):
for arg in args:
value = os.environ.get(arg, None)
if value:
return value
return kwargs.get('default', '')
| [
"def",
"env",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"for",
"arg",
"in",
"args",
":",
"value",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"arg",
",",
"None",
")",
"if",
"value",
":",
"return",
"value",
"return",
"kwargs",
".",
"get",
... | returns the first environment variable set . | train | true |
50,107 | def _argument_adapter(callback):
def wrapper(*args, **kwargs):
if (kwargs or (len(args) > 1)):
callback(Arguments(args, kwargs))
elif args:
callback(args[0])
else:
callback(None)
return wrapper
| [
"def",
"_argument_adapter",
"(",
"callback",
")",
":",
"def",
"wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"(",
"kwargs",
"or",
"(",
"len",
"(",
"args",
")",
">",
"1",
")",
")",
":",
"callback",
"(",
"Arguments",
"(",
"args",
... | returns a function that when invoked runs callback with one arg . | train | true |
50,108 | def should_vendor_libs():
vendor_libs = (not os.getenv(u'GIT_COLA_NO_VENDOR_LIBS', u''))
if (u'--no-vendor-libs' in sys.argv):
sys.argv.remove(u'--no-vendor-libs')
vendor_libs = False
return vendor_libs
| [
"def",
"should_vendor_libs",
"(",
")",
":",
"vendor_libs",
"=",
"(",
"not",
"os",
".",
"getenv",
"(",
"u'GIT_COLA_NO_VENDOR_LIBS'",
",",
"u''",
")",
")",
"if",
"(",
"u'--no-vendor-libs'",
"in",
"sys",
".",
"argv",
")",
":",
"sys",
".",
"argv",
".",
"remo... | return true if we should include vendored libraries . | train | false |
50,109 | def visit_snippet_latex(self, node):
self.verbatim = ''
| [
"def",
"visit_snippet_latex",
"(",
"self",
",",
"node",
")",
":",
"self",
".",
"verbatim",
"=",
"''"
] | latex document generator visit handler . | train | false |
50,110 | def load_marked_modules(cr, graph, states, force, progressdict, report, loaded_modules, perform_checks):
processed_modules = []
while True:
cr.execute('SELECT name from ir_module_module WHERE state IN %s', (tuple(states),))
module_list = [name for (name,) in cr.fetchall() if (name not in graph)]
if (not module_list):
break
graph.add_modules(cr, module_list, force)
_logger.debug('Updating graph with %d more modules', len(module_list))
(loaded, processed) = load_module_graph(cr, graph, progressdict, report=report, skip_modules=loaded_modules, perform_checks=perform_checks)
processed_modules.extend(processed)
loaded_modules.extend(loaded)
if (not processed):
break
return processed_modules
| [
"def",
"load_marked_modules",
"(",
"cr",
",",
"graph",
",",
"states",
",",
"force",
",",
"progressdict",
",",
"report",
",",
"loaded_modules",
",",
"perform_checks",
")",
":",
"processed_modules",
"=",
"[",
"]",
"while",
"True",
":",
"cr",
".",
"execute",
... | loads modules marked with states . | train | false |
50,111 | def slow(slowness_reason):
def decorator(f):
f.slowness_reason = slowness_reason
return f
return decorator
| [
"def",
"slow",
"(",
"slowness_reason",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"f",
".",
"slowness_reason",
"=",
"slowness_reason",
"return",
"f",
"return",
"decorator"
] | this is a decorate that annotates a test as being "known to be slow . | train | false |
50,112 | def _xfs_info_get_kv(serialized):
if serialized.startswith('='):
serialized = serialized[1:].strip()
serialized = serialized.replace(' = ', '=*** ').replace(' =', '=')
opt = []
for tkn in serialized.split(' '):
if ((not opt) or ('=' in tkn)):
opt.append(tkn)
else:
opt[(len(opt) - 1)] = ((opt[(len(opt) - 1)] + ' ') + tkn)
return [tuple(items.split('=')) for items in opt]
| [
"def",
"_xfs_info_get_kv",
"(",
"serialized",
")",
":",
"if",
"serialized",
".",
"startswith",
"(",
"'='",
")",
":",
"serialized",
"=",
"serialized",
"[",
"1",
":",
"]",
".",
"strip",
"(",
")",
"serialized",
"=",
"serialized",
".",
"replace",
"(",
"' = '... | parse one line of the xfs info output . | train | true |
50,113 | def get_is_file_present(name):
global NAME_PREFIX
name = name.replace(NAME_PREFIX, '')
filename = ('/' + name.replace('_present', '').replace('_', '/'))
if os.path.isfile(filename):
return 1
else:
return 0
| [
"def",
"get_is_file_present",
"(",
"name",
")",
":",
"global",
"NAME_PREFIX",
"name",
"=",
"name",
".",
"replace",
"(",
"NAME_PREFIX",
",",
"''",
")",
"filename",
"=",
"(",
"'/'",
"+",
"name",
".",
"replace",
"(",
"'_present'",
",",
"''",
")",
".",
"re... | find whether file exists . | train | false |
50,114 | def bridge_create(br, may_exist=True):
param_may_exist = _param_may_exist(may_exist)
cmd = 'ovs-vsctl {1}add-br {0}'.format(br, param_may_exist)
result = __salt__['cmd.run_all'](cmd)
return _retcode_to_bool(result['retcode'])
| [
"def",
"bridge_create",
"(",
"br",
",",
"may_exist",
"=",
"True",
")",
":",
"param_may_exist",
"=",
"_param_may_exist",
"(",
"may_exist",
")",
"cmd",
"=",
"'ovs-vsctl {1}add-br {0}'",
".",
"format",
"(",
"br",
",",
"param_may_exist",
")",
"result",
"=",
"__sal... | creates a new bridge . | train | false |
50,116 | def stripEscapes(s):
result = ''
show = 1
i = 0
L = len(s)
while (i < L):
if ((show == 0) and (s[i] in ANSI_TERMINATORS)):
show = 1
elif show:
n = s.find(ANSI_ESCAPE_BEGIN, i)
if (n == (-1)):
return (result + s[i:])
else:
result = (result + s[i:n])
i = n
show = 0
i += 1
return result
| [
"def",
"stripEscapes",
"(",
"s",
")",
":",
"result",
"=",
"''",
"show",
"=",
"1",
"i",
"=",
"0",
"L",
"=",
"len",
"(",
"s",
")",
"while",
"(",
"i",
"<",
"L",
")",
":",
"if",
"(",
"(",
"show",
"==",
"0",
")",
"and",
"(",
"s",
"[",
"i",
"... | remove all ansi color escapes from the given string . | train | false |
50,117 | def beneficiary_type():
return s3_rest_controller()
| [
"def",
"beneficiary_type",
"(",
")",
":",
"return",
"s3_rest_controller",
"(",
")"
] | restful crud controller . | train | false |
50,118 | def should_skip_file(name):
if name.startswith('.'):
return 'Skipping hidden file %(filename)s'
if name.endswith(('~', '.bak')):
return 'Skipping backup file %(filename)s'
if name.endswith(('.pyc', '.pyo')):
return (('Skipping %s file ' % os.path.splitext(name)[1]) + '%(filename)s')
if name.endswith('$py.class'):
return 'Skipping $py.class file %(filename)s'
if (name in ('CVS', '_darcs')):
return 'Skipping version control directory %(filename)s'
return None
| [
"def",
"should_skip_file",
"(",
"name",
")",
":",
"if",
"name",
".",
"startswith",
"(",
"'.'",
")",
":",
"return",
"'Skipping hidden file %(filename)s'",
"if",
"name",
".",
"endswith",
"(",
"(",
"'~'",
",",
"'.bak'",
")",
")",
":",
"return",
"'Skipping backu... | checks if a file should be skipped based on its name . | train | true |
50,123 | @np.deprecate(message='spleval is deprecated in scipy 0.19.0, use BSpline instead.')
def spleval(xck, xnew, deriv=0):
(xj, cvals, k) = xck
oldshape = np.shape(xnew)
xx = np.ravel(xnew)
sh = cvals.shape[1:]
res = np.empty((xx.shape + sh), dtype=cvals.dtype)
for index in np.ndindex(*sh):
sl = ((slice(None),) + index)
if issubclass(cvals.dtype.type, np.complexfloating):
res[sl].real = _fitpack._bspleval(xx, xj, cvals.real[sl], k, deriv)
res[sl].imag = _fitpack._bspleval(xx, xj, cvals.imag[sl], k, deriv)
else:
res[sl] = _fitpack._bspleval(xx, xj, cvals[sl], k, deriv)
res.shape = (oldshape + sh)
return res
| [
"@",
"np",
".",
"deprecate",
"(",
"message",
"=",
"'spleval is deprecated in scipy 0.19.0, use BSpline instead.'",
")",
"def",
"spleval",
"(",
"xck",
",",
"xnew",
",",
"deriv",
"=",
"0",
")",
":",
"(",
"xj",
",",
"cvals",
",",
"k",
")",
"=",
"xck",
"oldsha... | evaluate a fixed spline represented by the given tuple at the new x-values the xj values are the interior knot points . | train | false |
50,124 | def is_iterator(obj):
from types import GeneratorType
if isinstance(obj, GeneratorType):
return True
elif (not hasattr(obj, '__iter__')):
return False
else:
return (iter(obj) is obj)
| [
"def",
"is_iterator",
"(",
"obj",
")",
":",
"from",
"types",
"import",
"GeneratorType",
"if",
"isinstance",
"(",
"obj",
",",
"GeneratorType",
")",
":",
"return",
"True",
"elif",
"(",
"not",
"hasattr",
"(",
"obj",
",",
"'__iter__'",
")",
")",
":",
"return... | returns a boolean indicating if the object provided implements the iterator protocol . | train | false |
50,125 | def phooky():
exclusion_list = ['lafin', 'daniel_dressler', 'phooky']
g = globals()
flist = [(k, v) for (k, v) in g.items() if (isinstance(v, type(phooky)) and (k not in exclusion_list) and (v.func_code.co_argcount == 0))]
(names, bodies) = map(list, zip(*flist))
random.shuffle(bodies)
for (name, body) in zip(names, bodies):
g[name] = body
print 'phooky is now {0}!'.format(phooky.func_code.co_name)
| [
"def",
"phooky",
"(",
")",
":",
"exclusion_list",
"=",
"[",
"'lafin'",
",",
"'daniel_dressler'",
",",
"'phooky'",
"]",
"g",
"=",
"globals",
"(",
")",
"flist",
"=",
"[",
"(",
"k",
",",
"v",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"g",
".",
"i... | key party! everybodys function goes home with a different name than it showed up with . | train | false |
50,126 | def get_redis_server():
global redis_server
if (not redis_server):
from redis import Redis
redis_server = Redis.from_url((conf.get(u'redis_socketio') or u'redis://localhost:12311'))
return redis_server
| [
"def",
"get_redis_server",
"(",
")",
":",
"global",
"redis_server",
"if",
"(",
"not",
"redis_server",
")",
":",
"from",
"redis",
"import",
"Redis",
"redis_server",
"=",
"Redis",
".",
"from_url",
"(",
"(",
"conf",
".",
"get",
"(",
"u'redis_socketio'",
")",
... | returns redis_socketio connection . | train | false |
50,127 | def handle_unauthenticated(func):
@functools.wraps(func)
def wrapped(self, *args, **kwargs):
try:
return func(self, *args, **kwargs)
except exception.NotAuthenticated:
self._authenticate(force_reauth=True)
return func(self, *args, **kwargs)
return wrapped
| [
"def",
"handle_unauthenticated",
"(",
"func",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"func",
")",
"def",
"wrapped",
"(",
"self",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"try",
":",
"return",
"func",
"(",
"self",
",",
"*",
"args",
"... | wrap a function to re-authenticate and retry . | train | false |
50,131 | @handle_response_format
@treeio_login_required
@_process_mass_form
def index_resolved(request, response_format='html'):
query = (Q(object__in=Object.filter_by_request(request, Object.objects)) & Q(resolved_by=request.user.profile))
if request.GET:
query = (query & _get_filter_query(request.GET))
filters = FilterForm(request.user.profile, 'resolved_by', request.GET)
else:
filters = FilterForm(request.user.profile, 'resolved_by')
changesets = ChangeSet.objects.filter(query)
context = _get_default_context(request)
context.update({'filters': filters, 'changesets': changesets})
return render_to_response('changes/index_resolved', context, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"handle_response_format",
"@",
"treeio_login_required",
"@",
"_process_mass_form",
"def",
"index_resolved",
"(",
"request",
",",
"response_format",
"=",
"'html'",
")",
":",
"query",
"=",
"(",
"Q",
"(",
"object__in",
"=",
"Object",
".",
"filter_by_request",
"(... | change control resolved by me page . | train | false |
50,132 | def dmp_copy(f, u):
if (not u):
return list(f)
v = (u - 1)
return [dmp_copy(c, v) for c in f]
| [
"def",
"dmp_copy",
"(",
"f",
",",
"u",
")",
":",
"if",
"(",
"not",
"u",
")",
":",
"return",
"list",
"(",
"f",
")",
"v",
"=",
"(",
"u",
"-",
"1",
")",
"return",
"[",
"dmp_copy",
"(",
"c",
",",
"v",
")",
"for",
"c",
"in",
"f",
"]"
] | create a new copy of a polynomial f in k[x] . | train | false |
50,133 | @process_request_body
def yaml_processor(entity):
body = entity.fp.read()
try:
cherrypy.serving.request.unserialized_data = yaml.safe_load(body)
except ValueError:
raise cherrypy.HTTPError(400, 'Invalid YAML document')
cherrypy.serving.request.raw_body = body
| [
"@",
"process_request_body",
"def",
"yaml_processor",
"(",
"entity",
")",
":",
"body",
"=",
"entity",
".",
"fp",
".",
"read",
"(",
")",
"try",
":",
"cherrypy",
".",
"serving",
".",
"request",
".",
"unserialized_data",
"=",
"yaml",
".",
"safe_load",
"(",
... | unserialize raw post data in yaml format to a python data structure . | train | false |
50,134 | def xhtml():
return Markdown(output_format='xhtml', extensions=[ExtraExtension()])
| [
"def",
"xhtml",
"(",
")",
":",
"return",
"Markdown",
"(",
"output_format",
"=",
"'xhtml'",
",",
"extensions",
"=",
"[",
"ExtraExtension",
"(",
")",
"]",
")"
] | this makes a converter from markdown to xhtml format . | train | false |
50,135 | def attr(key, value=None):
key = target(key)
if (key is False):
return False
elif os.path.isdir(key):
return key
elif (value is not None):
return write(key, value)
else:
return read(key)
| [
"def",
"attr",
"(",
"key",
",",
"value",
"=",
"None",
")",
":",
"key",
"=",
"target",
"(",
"key",
")",
"if",
"(",
"key",
"is",
"False",
")",
":",
"return",
"False",
"elif",
"os",
".",
"path",
".",
"isdir",
"(",
"key",
")",
":",
"return",
"key",... | access/write a sysfs attribute . | train | true |
50,137 | @hook.command('loved')
def loved(db):
query = db.execute(select([karma_table]).order_by(karma_table.c.total_karma.desc()).limit(5)).fetchall()
if (not query):
return '??'
else:
return query
| [
"@",
"hook",
".",
"command",
"(",
"'loved'",
")",
"def",
"loved",
"(",
"db",
")",
":",
"query",
"=",
"db",
".",
"execute",
"(",
"select",
"(",
"[",
"karma_table",
"]",
")",
".",
"order_by",
"(",
"karma_table",
".",
"c",
".",
"total_karma",
".",
"de... | loved -- shows the users with the most karma! . | train | false |
50,138 | def libvlc_audio_toggle_mute(p_mi):
f = (_Cfunctions.get('libvlc_audio_toggle_mute', None) or _Cfunction('libvlc_audio_toggle_mute', ((1,),), None, None, MediaPlayer))
return f(p_mi)
| [
"def",
"libvlc_audio_toggle_mute",
"(",
"p_mi",
")",
":",
"f",
"=",
"(",
"_Cfunctions",
".",
"get",
"(",
"'libvlc_audio_toggle_mute'",
",",
"None",
")",
"or",
"_Cfunction",
"(",
"'libvlc_audio_toggle_mute'",
",",
"(",
"(",
"1",
",",
")",
",",
")",
",",
"No... | toggle mute status . | train | false |
50,139 | def _neweywestcov(resid, x):
nobs = resid.shape[0]
nlags = int(round((4 * ((nobs / 100.0) ** (2 / 9.0)))))
hhat = (resid * x.T)
xuux = np.dot(hhat, hhat.T)
for lag in range(nlags):
za = np.dot(hhat[:, lag:nobs], hhat[:, :(nobs - lag)].T)
w = (1 - (lag / (nobs + 1.0)))
xuux = (xuux + np.dot(w, (za + za.T)))
xtxi = np.linalg.inv(np.dot(x.T, x))
covbNW = np.dot(xtxi, np.dot(xuux, xtxi))
return covbNW
| [
"def",
"_neweywestcov",
"(",
"resid",
",",
"x",
")",
":",
"nobs",
"=",
"resid",
".",
"shape",
"[",
"0",
"]",
"nlags",
"=",
"int",
"(",
"round",
"(",
"(",
"4",
"*",
"(",
"(",
"nobs",
"/",
"100.0",
")",
"**",
"(",
"2",
"/",
"9.0",
")",
")",
"... | did not run yet from regstats2 :: if idx % hac l = round(4*^); % l = nobs^ . | train | false |
50,140 | def test_no_data_with_none(Chart):
chart = Chart()
chart.add('Serie', None)
q = chart.render_pyquery()
assert (q('.text-overlay text').text() == 'No data')
| [
"def",
"test_no_data_with_none",
"(",
"Chart",
")",
":",
"chart",
"=",
"Chart",
"(",
")",
"chart",
".",
"add",
"(",
"'Serie'",
",",
"None",
")",
"q",
"=",
"chart",
".",
"render_pyquery",
"(",
")",
"assert",
"(",
"q",
"(",
"'.text-overlay text'",
")",
"... | test no data for a none containing serie . | train | false |
50,141 | def splev(x, tck, der=0, ext=0):
(t, c, k) = tck
try:
c[0][0]
parametric = True
except:
parametric = False
if parametric:
return list(map((lambda c, x=x, t=t, k=k, der=der: splev(x, [t, c, k], der, ext)), c))
else:
if (not (0 <= der <= k)):
raise ValueError(('0<=der=%d<=k=%d must hold' % (der, k)))
if (ext not in (0, 1, 2, 3)):
raise ValueError(('ext = %s not in (0, 1, 2, 3) ' % ext))
x = asarray(x)
shape = x.shape
x = atleast_1d(x).ravel()
(y, ier) = _fitpack._spl_(x, der, t, c, k, ext)
if (ier == 10):
raise ValueError('Invalid input data')
if (ier == 1):
raise ValueError('Found x value not in the domain')
if ier:
raise TypeError('An error occurred')
return y.reshape(shape)
| [
"def",
"splev",
"(",
"x",
",",
"tck",
",",
"der",
"=",
"0",
",",
"ext",
"=",
"0",
")",
":",
"(",
"t",
",",
"c",
",",
"k",
")",
"=",
"tck",
"try",
":",
"c",
"[",
"0",
"]",
"[",
"0",
"]",
"parametric",
"=",
"True",
"except",
":",
"parametri... | evaluate a b-spline or its derivatives . | train | false |
50,142 | def generate_content(data):
try:
return (templates[data['type']][data['event']] % data['values'])
except KeyError:
return json_error(_('Unknown message'))
| [
"def",
"generate_content",
"(",
"data",
")",
":",
"try",
":",
"return",
"(",
"templates",
"[",
"data",
"[",
"'type'",
"]",
"]",
"[",
"data",
"[",
"'event'",
"]",
"]",
"%",
"data",
"[",
"'values'",
"]",
")",
"except",
"KeyError",
":",
"return",
"json_... | gets the template string and formats it with parsed data . | train | false |
50,143 | def get_or_create_mrjob_instance_profile(conn):
for (profile_name, role_name, role_document) in _yield_instance_profiles(conn):
if (role_document != _MRJOB_INSTANCE_PROFILE_ROLE):
continue
policy_arns = list(_yield_attached_role_policies(conn, role_name))
if (policy_arns == [_EMR_INSTANCE_PROFILE_POLICY_ARN]):
return role_name
name = _create_mrjob_role_with_attached_policy(conn, _MRJOB_INSTANCE_PROFILE_ROLE, _EMR_INSTANCE_PROFILE_POLICY_ARN)
conn.create_instance_profile(name)
conn.add_role_to_instance_profile(name, name)
log.info(('Auto-created instance profile %s' % name))
return name
| [
"def",
"get_or_create_mrjob_instance_profile",
"(",
"conn",
")",
":",
"for",
"(",
"profile_name",
",",
"role_name",
",",
"role_document",
")",
"in",
"_yield_instance_profiles",
"(",
"conn",
")",
":",
"if",
"(",
"role_document",
"!=",
"_MRJOB_INSTANCE_PROFILE_ROLE",
... | look for a usable instance profile for emr . | train | false |
50,147 | def _order_complex_poles(poles):
ordered_poles = np.sort(poles[np.isreal(poles)])
im_poles = []
for p in np.sort(poles[(np.imag(poles) < 0)]):
if (np.conj(p) in poles):
im_poles.extend((p, np.conj(p)))
ordered_poles = np.hstack((ordered_poles, im_poles))
if (poles.shape[0] != len(ordered_poles)):
raise ValueError('Complex poles must come with their conjugates')
return ordered_poles
| [
"def",
"_order_complex_poles",
"(",
"poles",
")",
":",
"ordered_poles",
"=",
"np",
".",
"sort",
"(",
"poles",
"[",
"np",
".",
"isreal",
"(",
"poles",
")",
"]",
")",
"im_poles",
"=",
"[",
"]",
"for",
"p",
"in",
"np",
".",
"sort",
"(",
"poles",
"[",
... | check we have complex conjugates pairs and reorder p according to yt . | train | false |
50,148 | def getAroundsFromLoops(loops, radius, thresholdRatio=0.9):
return getAroundsFromPoints(getPointsFromLoops(loops, radius, thresholdRatio), radius)
| [
"def",
"getAroundsFromLoops",
"(",
"loops",
",",
"radius",
",",
"thresholdRatio",
"=",
"0.9",
")",
":",
"return",
"getAroundsFromPoints",
"(",
"getPointsFromLoops",
"(",
"loops",
",",
"radius",
",",
"thresholdRatio",
")",
",",
"radius",
")"
] | get the arounds from the loops . | train | false |
50,150 | def pop_path_info(environ, charset='utf-8', errors='replace'):
path = environ.get('PATH_INFO')
if (not path):
return None
script_name = environ.get('SCRIPT_NAME', '')
old_path = path
path = path.lstrip('/')
if (path != old_path):
script_name += ('/' * (len(old_path) - len(path)))
if ('/' not in path):
environ['PATH_INFO'] = ''
environ['SCRIPT_NAME'] = (script_name + path)
rv = wsgi_get_bytes(path)
else:
(segment, path) = path.split('/', 1)
environ['PATH_INFO'] = ('/' + path)
environ['SCRIPT_NAME'] = (script_name + segment)
rv = wsgi_get_bytes(segment)
return to_unicode(rv, charset, errors, allow_none_charset=True)
| [
"def",
"pop_path_info",
"(",
"environ",
",",
"charset",
"=",
"'utf-8'",
",",
"errors",
"=",
"'replace'",
")",
":",
"path",
"=",
"environ",
".",
"get",
"(",
"'PATH_INFO'",
")",
"if",
"(",
"not",
"path",
")",
":",
"return",
"None",
"script_name",
"=",
"e... | removes and returns the next segment of path_info . | train | true |
50,151 | def SubTemplateElement(parent, tag, attrib=None, selector=None, subselector=None, **extra):
attrib = (attrib or {})
attrib.update(extra)
elem = TemplateElement(tag, attrib=attrib, selector=selector, subselector=subselector)
if (parent is not None):
parent.append(elem)
return elem
| [
"def",
"SubTemplateElement",
"(",
"parent",
",",
"tag",
",",
"attrib",
"=",
"None",
",",
"selector",
"=",
"None",
",",
"subselector",
"=",
"None",
",",
"**",
"extra",
")",
":",
"attrib",
"=",
"(",
"attrib",
"or",
"{",
"}",
")",
"attrib",
".",
"update... | create a template element as a child of another . | train | false |
50,153 | @connect_on_app_finalize
def add_chain_task(app):
@app.task(name=u'celery.chain', shared=False, lazy=False)
def chain(*args, **kwargs):
raise NotImplementedError(u'chain is not a real task')
return chain
| [
"@",
"connect_on_app_finalize",
"def",
"add_chain_task",
"(",
"app",
")",
":",
"@",
"app",
".",
"task",
"(",
"name",
"=",
"u'celery.chain'",
",",
"shared",
"=",
"False",
",",
"lazy",
"=",
"False",
")",
"def",
"chain",
"(",
"*",
"args",
",",
"**",
"kwar... | no longer used . | train | false |
50,155 | def LU(matlist, K, reverse=0):
nrow = len(matlist)
(new_matlist1, new_matlist2) = (eye(nrow, K), copy.deepcopy(matlist))
for i in range(nrow):
for j in range((i + 1), nrow):
if (new_matlist2[j][i] != 0):
new_matlist1[j][i] = (new_matlist2[j][i] / new_matlist2[i][i])
rowadd(new_matlist2, j, i, ((- new_matlist2[j][i]) / new_matlist2[i][i]), K)
return (new_matlist1, new_matlist2)
| [
"def",
"LU",
"(",
"matlist",
",",
"K",
",",
"reverse",
"=",
"0",
")",
":",
"nrow",
"=",
"len",
"(",
"matlist",
")",
"(",
"new_matlist1",
",",
"new_matlist2",
")",
"=",
"(",
"eye",
"(",
"nrow",
",",
"K",
")",
",",
"copy",
".",
"deepcopy",
"(",
"... | it computes the lu decomposition of a matrix and returns l and u matrices . | train | false |
50,157 | def _is_attribute_property(name, klass):
try:
attributes = klass.getattr(name)
except astroid.NotFoundError:
return False
property_name = '{0}.property'.format(BUILTINS)
for attr in attributes:
try:
infered = next(attr.infer())
except astroid.InferenceError:
continue
if (isinstance(infered, astroid.Function) and decorated_with_property(infered)):
return True
if (infered.pytype() == property_name):
return True
return False
| [
"def",
"_is_attribute_property",
"(",
"name",
",",
"klass",
")",
":",
"try",
":",
"attributes",
"=",
"klass",
".",
"getattr",
"(",
"name",
")",
"except",
"astroid",
".",
"NotFoundError",
":",
"return",
"False",
"property_name",
"=",
"'{0}.property'",
".",
"f... | check if the given attribute *name* is a property in the given *klass* . | train | true |
50,158 | def _RaiseInvalidWireType(buffer, pos, end):
raise _DecodeError('Tag had invalid wire type.')
| [
"def",
"_RaiseInvalidWireType",
"(",
"buffer",
",",
"pos",
",",
"end",
")",
":",
"raise",
"_DecodeError",
"(",
"'Tag had invalid wire type.'",
")"
] | skip function for unknown wire types . | train | false |
50,160 | @task(base=BaseInstructorTask)
def export_ora2_data(entry_id, xmodule_instance_args):
action_name = ugettext_noop('generated')
task_fn = partial(upload_ora2_data, xmodule_instance_args)
return run_main_task(entry_id, task_fn, action_name)
| [
"@",
"task",
"(",
"base",
"=",
"BaseInstructorTask",
")",
"def",
"export_ora2_data",
"(",
"entry_id",
",",
"xmodule_instance_args",
")",
":",
"action_name",
"=",
"ugettext_noop",
"(",
"'generated'",
")",
"task_fn",
"=",
"partial",
"(",
"upload_ora2_data",
",",
"... | generate a csv of ora2 responses and push it to s3 . | train | false |
50,161 | def check_success(ODBC_obj, ret):
if (ret not in (SQL_SUCCESS, SQL_SUCCESS_WITH_INFO, SQL_NO_DATA)):
if isinstance(ODBC_obj, Cursor):
ctrl_err(SQL_HANDLE_STMT, ODBC_obj.stmt_h, ret, ODBC_obj.ansi)
elif isinstance(ODBC_obj, Connection):
ctrl_err(SQL_HANDLE_DBC, ODBC_obj.dbc_h, ret, ODBC_obj.ansi)
else:
ctrl_err(SQL_HANDLE_ENV, ODBC_obj, ret, False)
| [
"def",
"check_success",
"(",
"ODBC_obj",
",",
"ret",
")",
":",
"if",
"(",
"ret",
"not",
"in",
"(",
"SQL_SUCCESS",
",",
"SQL_SUCCESS_WITH_INFO",
",",
"SQL_NO_DATA",
")",
")",
":",
"if",
"isinstance",
"(",
"ODBC_obj",
",",
"Cursor",
")",
":",
"ctrl_err",
"... | validate return value . | train | false |
50,162 | def cleanup_coverage_dir():
output_dir = os.path.join(coverage_path, 'output')
for filename in os.listdir(output_dir):
src = os.path.join(output_dir, filename)
dst = os.path.join(os.getcwd(), 'test', 'results', 'coverage')
shutil.copy(src, dst)
logs_dir = os.path.join(coverage_path, 'logs')
for filename in os.listdir(logs_dir):
random_suffix = ''.join((random.choice((string.ascii_letters + string.digits)) for _ in range(8)))
new_name = ('%s.%s.log' % (os.path.splitext(os.path.basename(filename))[0], random_suffix))
src = os.path.join(logs_dir, filename)
dst = os.path.join(os.getcwd(), 'test', 'results', 'logs', new_name)
shutil.copy(src, dst)
shutil.rmtree(coverage_path)
| [
"def",
"cleanup_coverage_dir",
"(",
")",
":",
"output_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"coverage_path",
",",
"'output'",
")",
"for",
"filename",
"in",
"os",
".",
"listdir",
"(",
"output_dir",
")",
":",
"src",
"=",
"os",
".",
"path",
".",... | copy over coverage data from temporary directory and purge temporary directory . | train | false |
50,164 | def describe_function(FunctionName, region=None, key=None, keyid=None, profile=None):
try:
func = _find_function(FunctionName, region=region, key=key, keyid=keyid, profile=profile)
if func:
keys = ('FunctionName', 'Runtime', 'Role', 'Handler', 'CodeSha256', 'CodeSize', 'Description', 'Timeout', 'MemorySize', 'FunctionArn', 'LastModified', 'VpcConfig')
return {'function': dict([(k, func.get(k)) for k in keys])}
else:
return {'function': None}
except ClientError as e:
return {'error': salt.utils.boto3.get_error(e)}
| [
"def",
"describe_function",
"(",
"FunctionName",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"try",
":",
"func",
"=",
"_find_function",
"(",
"FunctionName",
",",
"region",
"=",
... | given a function name describe its properties . | train | false |
50,165 | @ndb.transactional
def update_counter(name):
counter = Counter.get_by_id(name)
if (counter is None):
counter = Counter(id=name, count=0)
counter.count += 1
counter.put()
return counter.count
| [
"@",
"ndb",
".",
"transactional",
"def",
"update_counter",
"(",
"name",
")",
":",
"counter",
"=",
"Counter",
".",
"get_by_id",
"(",
"name",
")",
"if",
"(",
"counter",
"is",
"None",
")",
":",
"counter",
"=",
"Counter",
"(",
"id",
"=",
"name",
",",
"co... | increment the named counter by 1 . | train | false |
50,167 | def test_global():
global_assumptions.add(Q.is_true((x > 0)))
assert (Q.is_true((x > 0)) in global_assumptions)
global_assumptions.remove(Q.is_true((x > 0)))
assert (not (Q.is_true((x > 0)) in global_assumptions))
global_assumptions.add(Q.is_true((x > 0)), Q.is_true((y > 0)))
assert (Q.is_true((x > 0)) in global_assumptions)
assert (Q.is_true((y > 0)) in global_assumptions)
global_assumptions.clear()
assert (not (Q.is_true((x > 0)) in global_assumptions))
assert (not (Q.is_true((y > 0)) in global_assumptions))
| [
"def",
"test_global",
"(",
")",
":",
"global_assumptions",
".",
"add",
"(",
"Q",
".",
"is_true",
"(",
"(",
"x",
">",
"0",
")",
")",
")",
"assert",
"(",
"Q",
".",
"is_true",
"(",
"(",
"x",
">",
"0",
")",
")",
"in",
"global_assumptions",
")",
"glob... | test for global assumptions . | train | false |
50,169 | def addNegativesByDerivation(end, extrudeDerivation, negatives, radius, start, xmlElement):
extrudeDerivation.offsetAlongDefault = [start, end]
extrudeDerivation.tiltFollow = True
extrudeDerivation.tiltTop = Vector3(0.0, 0.0, 1.0)
extrudeDerivation.setToXMLElement(xmlElement.getCopyShallow())
extrude.addNegatives(extrudeDerivation, negatives, [getTeardropPathByEndStart(end, radius, start, xmlElement)])
| [
"def",
"addNegativesByDerivation",
"(",
"end",
",",
"extrudeDerivation",
",",
"negatives",
",",
"radius",
",",
"start",
",",
"xmlElement",
")",
":",
"extrudeDerivation",
".",
"offsetAlongDefault",
"=",
"[",
"start",
",",
"end",
"]",
"extrudeDerivation",
".",
"ti... | add teardrop drill hole to negatives . | train | false |
50,170 | def _send_splunk(event, index_override=None, sourcetype_override=None):
opts = _get_options()
logging.info('Options: {0}'.format(json.dumps(opts)))
http_event_collector_key = opts['token']
http_event_collector_host = opts['indexer']
splunk_event = http_event_collector(http_event_collector_key, http_event_collector_host)
payload = {}
if (index_override is None):
payload.update({'index': opts['index']})
else:
payload.update({'index': index_override})
if (sourcetype_override is None):
payload.update({'sourcetype': opts['sourcetype']})
else:
payload.update({'index': sourcetype_override})
payload.update({'event': event})
logging.info('Payload: {0}'.format(json.dumps(payload)))
splunk_event.sendEvent(payload)
return True
| [
"def",
"_send_splunk",
"(",
"event",
",",
"index_override",
"=",
"None",
",",
"sourcetype_override",
"=",
"None",
")",
":",
"opts",
"=",
"_get_options",
"(",
")",
"logging",
".",
"info",
"(",
"'Options: {0}'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",... | send the results to splunk . | train | false |
50,171 | def get_code_expiry():
return (now() + EXPIRE_CODE_DELTA)
| [
"def",
"get_code_expiry",
"(",
")",
":",
"return",
"(",
"now",
"(",
")",
"+",
"EXPIRE_CODE_DELTA",
")"
] | return a datetime object indicating when an authorization code should expire . | train | false |
50,172 | def elimination_technique_2(C):
rels = C._reidemeister_relators
rels.sort(reverse=True)
gens = C._schreier_generators
for i in range((len(gens) - 1), (-1), (-1)):
rel = rels[i]
for j in range((len(gens) - 1), (-1), (-1)):
gen = gens[j]
if (rel.generator_count(gen) == 1):
k = rel.exponent_sum(gen)
gen_index = rel.index((gen ** k))
bk = rel.subword((gen_index + 1), len(rel))
fw = rel.subword(0, gen_index)
rep_by = ((bk * fw) ** ((-1) * k))
del rels[i]
del gens[j]
for l in range(len(rels)):
rels[l] = rels[l].eliminate_word(gen, rep_by)
break
C._reidemeister_relators = rels
C._schreier_generators = gens
return (C._schreier_generators, C._reidemeister_relators)
| [
"def",
"elimination_technique_2",
"(",
"C",
")",
":",
"rels",
"=",
"C",
".",
"_reidemeister_relators",
"rels",
".",
"sort",
"(",
"reverse",
"=",
"True",
")",
"gens",
"=",
"C",
".",
"_schreier_generators",
"for",
"i",
"in",
"range",
"(",
"(",
"len",
"(",
... | this technique eliminates one generator at a time . | train | false |
50,173 | def _print_baremetal_node_interfaces(interfaces):
utils.print_list(interfaces, ['ID', 'Datapath_ID', 'Port_No', 'Address'])
| [
"def",
"_print_baremetal_node_interfaces",
"(",
"interfaces",
")",
":",
"utils",
".",
"print_list",
"(",
"interfaces",
",",
"[",
"'ID'",
",",
"'Datapath_ID'",
",",
"'Port_No'",
",",
"'Address'",
"]",
")"
] | print interfaces of a baremetal node . | train | false |
50,175 | def clean_title(title):
result = TitleParser.remove_words(title, (TitleParser.sounds + TitleParser.codecs))
result = clean_symbols(result)
return result
| [
"def",
"clean_title",
"(",
"title",
")",
":",
"result",
"=",
"TitleParser",
".",
"remove_words",
"(",
"title",
",",
"(",
"TitleParser",
".",
"sounds",
"+",
"TitleParser",
".",
"codecs",
")",
")",
"result",
"=",
"clean_symbols",
"(",
"result",
")",
"return"... | removes common codec . | train | false |
50,176 | def report_entire_month(month_date, start_hour=0, start_day=1):
(year, month) = month_date.split('-')
(year, month) = (int(year), int(month))
hours = xrange(start_hour, 24)
for day in xrange(start_day, (calendar.monthrange(year, month)[1] + 1)):
for hour in hours:
hour_date = ('%04d-%02d-%02d-%02d' % (year, month, day, hour))
try:
report_interval(hour_date, background=False)
except ValueError:
print ('Failed for %s' % hour_date)
continue
hours = xrange(24)
day_date = ('%04d-%02d-%02d' % (year, month, day))
try:
report_interval(day_date, background=False)
except ValueError:
print ('Failed for %s' % day_date)
continue
report_interval(month_date, background=False)
| [
"def",
"report_entire_month",
"(",
"month_date",
",",
"start_hour",
"=",
"0",
",",
"start_day",
"=",
"1",
")",
":",
"(",
"year",
",",
"month",
")",
"=",
"month_date",
".",
"split",
"(",
"'-'",
")",
"(",
"year",
",",
"month",
")",
"=",
"(",
"int",
"... | report all hours and days from month . | train | false |
50,177 | def discover_servers(subnet='255.255.255.255', timeout=1):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
s.sendto(QUERY_MAGIC, (subnet, UDP_DISCOVERY_PORT))
replies = []
while True:
(rlist, dummy, dummy) = select.select([s], [], [], timeout)
if (not rlist):
break
(data, (addr, port)) = s.recvfrom(MAX_DGRAM_SIZE)
(rpyc_port,) = struct.unpack('<H', data)
replies.append((addr, rpyc_port))
return list(set(replies))
| [
"def",
"discover_servers",
"(",
"subnet",
"=",
"'255.255.255.255'",
",",
"timeout",
"=",
"1",
")",
":",
"s",
"=",
"socket",
".",
"socket",
"(",
"socket",
".",
"AF_INET",
",",
"socket",
".",
"SOCK_DGRAM",
")",
"s",
".",
"setsockopt",
"(",
"socket",
".",
... | broadcasts a query and returns a list of of running servers . | train | false |
50,178 | def _shell_wrap_inner(command, shell=True, sudo_prefix=None):
if (shell and (not env.use_shell)):
shell = False
if (sudo_prefix is None):
sudo_prefix = ''
else:
sudo_prefix += ' '
if shell:
shell = (env.shell + ' ')
command = ('"%s"' % command)
else:
shell = ''
return ((sudo_prefix + shell) + command)
| [
"def",
"_shell_wrap_inner",
"(",
"command",
",",
"shell",
"=",
"True",
",",
"sudo_prefix",
"=",
"None",
")",
":",
"if",
"(",
"shell",
"and",
"(",
"not",
"env",
".",
"use_shell",
")",
")",
":",
"shell",
"=",
"False",
"if",
"(",
"sudo_prefix",
"is",
"N... | conditionally wrap given command in env . | train | false |
50,180 | def _combine_ws(parts, whitespace):
out = []
ws = ''
for part in parts:
if (not part):
continue
elif (part in whitespace):
ws += part
else:
out.append((ws + part))
ws = ''
if ws:
out.append(ws)
return out
| [
"def",
"_combine_ws",
"(",
"parts",
",",
"whitespace",
")",
":",
"out",
"=",
"[",
"]",
"ws",
"=",
"''",
"for",
"part",
"in",
"parts",
":",
"if",
"(",
"not",
"part",
")",
":",
"continue",
"elif",
"(",
"part",
"in",
"whitespace",
")",
":",
"ws",
"+... | combine whitespace in a list with the element following it . | train | false |
50,181 | def poweroff():
return shutdown()
| [
"def",
"poweroff",
"(",
")",
":",
"return",
"shutdown",
"(",
")"
] | poweroff a running system cli example: . | train | false |
50,182 | def pretty_html(container, name, raw):
root = container.parse_xhtml(raw)
pretty_html_tree(container, root)
return serialize(root, u'text/html')
| [
"def",
"pretty_html",
"(",
"container",
",",
"name",
",",
"raw",
")",
":",
"root",
"=",
"container",
".",
"parse_xhtml",
"(",
"raw",
")",
"pretty_html_tree",
"(",
"container",
",",
"root",
")",
"return",
"serialize",
"(",
"root",
",",
"u'text/html'",
")"
] | pretty print the html represented as a string in raw . | train | false |
50,184 | def roc_auc_score(y_true, y_score, average='macro', sample_weight=None):
def _binary_roc_auc_score(y_true, y_score, sample_weight=None):
if (len(np.unique(y_true)) != 2):
raise ValueError('Only one class present in y_true. ROC AUC score is not defined in that case.')
(fpr, tpr, tresholds) = roc_curve(y_true, y_score, sample_weight=sample_weight)
return auc(fpr, tpr, reorder=True)
return _average_binary_score(_binary_roc_auc_score, y_true, y_score, average, sample_weight=sample_weight)
| [
"def",
"roc_auc_score",
"(",
"y_true",
",",
"y_score",
",",
"average",
"=",
"'macro'",
",",
"sample_weight",
"=",
"None",
")",
":",
"def",
"_binary_roc_auc_score",
"(",
"y_true",
",",
"y_score",
",",
"sample_weight",
"=",
"None",
")",
":",
"if",
"(",
"len"... | compute area under the curve from prediction scores note: this implementation is restricted to the binary classification task or multilabel classification task in label indicator format . | train | false |
50,185 | def concatenate_epochs(epochs_list):
return _finish_concat(*_concatenate_epochs(epochs_list))
| [
"def",
"concatenate_epochs",
"(",
"epochs_list",
")",
":",
"return",
"_finish_concat",
"(",
"*",
"_concatenate_epochs",
"(",
"epochs_list",
")",
")"
] | concatenate a list of epochs into one epochs object . | train | false |
50,186 | def extend_system_path(paths):
old_PATH = compat.getenv('PATH', '')
paths.append(old_PATH)
new_PATH = os.pathsep.join(paths)
compat.setenv('PATH', new_PATH)
| [
"def",
"extend_system_path",
"(",
"paths",
")",
":",
"old_PATH",
"=",
"compat",
".",
"getenv",
"(",
"'PATH'",
",",
"''",
")",
"paths",
".",
"append",
"(",
"old_PATH",
")",
"new_PATH",
"=",
"os",
".",
"pathsep",
".",
"join",
"(",
"paths",
")",
"compat",... | add new paths at the beginning of environment variable path . | train | false |
50,188 | def arr_to_2d(arr, oned_as='row'):
dims = matdims(arr, oned_as)
if (len(dims) > 2):
raise ValueError('Matlab 4 files cannot save arrays with more than 2 dimensions')
return arr.reshape(dims)
| [
"def",
"arr_to_2d",
"(",
"arr",
",",
"oned_as",
"=",
"'row'",
")",
":",
"dims",
"=",
"matdims",
"(",
"arr",
",",
"oned_as",
")",
"if",
"(",
"len",
"(",
"dims",
")",
">",
"2",
")",
":",
"raise",
"ValueError",
"(",
"'Matlab 4 files cannot save arrays with ... | make arr exactly two dimensional if arr has more than 2 dimensions . | train | false |
50,189 | def is_palindrome(num):
reverse = 0
num2 = num
while (num2 > 0):
reverse = ((10 * reverse) + (num2 % 10))
num2 //= 10
return (True if (reverse == num) else False)
| [
"def",
"is_palindrome",
"(",
"num",
")",
":",
"reverse",
"=",
"0",
"num2",
"=",
"num",
"while",
"(",
"num2",
">",
"0",
")",
":",
"reverse",
"=",
"(",
"(",
"10",
"*",
"reverse",
")",
"+",
"(",
"num2",
"%",
"10",
")",
")",
"num2",
"//=",
"10",
... | returns true if integer is a palindrome . | train | false |
50,190 | def untar(tarball):
if os.path.exists(sdist_root):
shutil.rmtree(sdist_root)
os.makedirs(sdist_root)
with cd(sdist_root):
run(['tar', '-xzf', tarball])
return glob.glob(pjoin(sdist_root, '*'))[0]
| [
"def",
"untar",
"(",
"tarball",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"sdist_root",
")",
":",
"shutil",
".",
"rmtree",
"(",
"sdist_root",
")",
"os",
".",
"makedirs",
"(",
"sdist_root",
")",
"with",
"cd",
"(",
"sdist_root",
")",
":",
... | extract sdist . | train | false |
50,191 | def vb_clone_vm(name=None, clone_from=None, timeout=10000, **kwargs):
vbox = vb_get_box()
log.info('Clone virtualbox machine %s from %s', name, clone_from)
source_machine = vbox.findMachine(clone_from)
groups = None
os_type_id = 'Other'
new_machine = vbox.createMachine(None, name, groups, os_type_id, None)
progress = source_machine.cloneTo(new_machine, 0, None)
progress.waitForCompletion(timeout)
log.info('Finished cloning %s from %s', name, clone_from)
vbox.registerMachine(new_machine)
return vb_xpcom_to_attribute_dict(new_machine, 'IMachine')
| [
"def",
"vb_clone_vm",
"(",
"name",
"=",
"None",
",",
"clone_from",
"=",
"None",
",",
"timeout",
"=",
"10000",
",",
"**",
"kwargs",
")",
":",
"vbox",
"=",
"vb_get_box",
"(",
")",
"log",
".",
"info",
"(",
"'Clone virtualbox machine %s from %s'",
",",
"name",... | tells virtualbox to create a vm by cloning from an existing one . | train | true |
50,192 | def _prepare_env(subject, subjects_dir, requires_freesurfer, requires_mne):
env = os.environ.copy()
if (requires_freesurfer and (not os.environ.get('FREESURFER_HOME'))):
raise RuntimeError('I cannot find freesurfer. The FREESURFER_HOME environment variable is not set.')
if (requires_mne and (not os.environ.get('MNE_ROOT'))):
raise RuntimeError('I cannot find the MNE command line tools. The MNE_ROOT environment variable is not set.')
if (not isinstance(subject, string_types)):
raise TypeError('The subject argument must be set')
subjects_dir = get_subjects_dir(subjects_dir, raise_error=True)
if (not op.isdir(subjects_dir)):
raise RuntimeError(('Could not find the MRI data directory "%s"' % subjects_dir))
subject_dir = op.join(subjects_dir, subject)
if (not op.isdir(subject_dir)):
raise RuntimeError(('Could not find the subject data directory "%s"' % (subject_dir,)))
env['SUBJECT'] = subject
env['SUBJECTS_DIR'] = subjects_dir
mri_dir = op.join(subject_dir, 'mri')
bem_dir = op.join(subject_dir, 'bem')
return (env, mri_dir, bem_dir)
| [
"def",
"_prepare_env",
"(",
"subject",
",",
"subjects_dir",
",",
"requires_freesurfer",
",",
"requires_mne",
")",
":",
"env",
"=",
"os",
".",
"environ",
".",
"copy",
"(",
")",
"if",
"(",
"requires_freesurfer",
"and",
"(",
"not",
"os",
".",
"environ",
".",
... | helper to prepare an env object for subprocess calls . | train | false |
50,193 | def write_module_styles(output_root):
return _write_styles('.xmodule_display', output_root, _list_modules())
| [
"def",
"write_module_styles",
"(",
"output_root",
")",
":",
"return",
"_write_styles",
"(",
"'.xmodule_display'",
",",
"output_root",
",",
"_list_modules",
"(",
")",
")"
] | write all registered xmodule css . | train | false |
50,194 | def list_remove(t):
(owner, slug) = get_slug()
user_name = raw_input(light_magenta('Give me name of the unlucky one: ', rl=True))
if user_name.startswith('@'):
user_name = user_name[1:]
try:
t.lists.members.destroy(slug=slug, owner_screen_name=owner, screen_name=user_name)
printNicely(green('Gone.'))
except:
debug_option()
printNicely(light_magenta("I'm sorry we can not remove him/her."))
| [
"def",
"list_remove",
"(",
"t",
")",
":",
"(",
"owner",
",",
"slug",
")",
"=",
"get_slug",
"(",
")",
"user_name",
"=",
"raw_input",
"(",
"light_magenta",
"(",
"'Give me name of the unlucky one: '",
",",
"rl",
"=",
"True",
")",
")",
"if",
"user_name",
".",
... | remove specific user from a list . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.