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 |
|---|---|---|---|---|---|
22,556 | def listps(num, order):
cmd = 'ps max -o pid,ppid,pcpu,pmem,rss,vsz,lwp,nlwp,lstart,cmd'
cmd += (' --sort -%s' % order)
title = 'Process/Threads details:'
ps_info = utils.system_output(cmd, verbose=False).splitlines()
if (num != 0):
(cnt, idx) = (0, 0)
title = ('Top %d process/threads details, ' % num)
title += ('order by %s:' % order)
for line in ps_info:
idx += 1
if re.match('^\\s+\\d', line):
cnt += 1
if (cnt > num):
break
ps_info = ps_info[:idx]
ps_info.insert(0, title)
return ps_info
| [
"def",
"listps",
"(",
"num",
",",
"order",
")",
":",
"cmd",
"=",
"'ps max -o pid,ppid,pcpu,pmem,rss,vsz,lwp,nlwp,lstart,cmd'",
"cmd",
"+=",
"(",
"' --sort -%s'",
"%",
"order",
")",
"title",
"=",
"'Process/Threads details:'",
"ps_info",
"=",
"utils",
".",
"system_output",
"(",
"cmd",
",",
"verbose",
"=",
"False",
")",
".",
"splitlines",
"(",
")",
"if",
"(",
"num",
"!=",
"0",
")",
":",
"(",
"cnt",
",",
"idx",
")",
"=",
"(",
"0",
",",
"0",
")",
"title",
"=",
"(",
"'Top %d process/threads details, '",
"%",
"num",
")",
"title",
"+=",
"(",
"'order by %s:'",
"%",
"order",
")",
"for",
"line",
"in",
"ps_info",
":",
"idx",
"+=",
"1",
"if",
"re",
".",
"match",
"(",
"'^\\\\s+\\\\d'",
",",
"line",
")",
":",
"cnt",
"+=",
"1",
"if",
"(",
"cnt",
">",
"num",
")",
":",
"break",
"ps_info",
"=",
"ps_info",
"[",
":",
"idx",
"]",
"ps_info",
".",
"insert",
"(",
"0",
",",
"title",
")",
"return",
"ps_info"
] | select top num process order by $order from system . | train | false |
22,557 | def B_0123(x, der=0):
x = np.atleast_1d(x)
conds = [(x < 1), ((x > 1) & (x < 2)), (x > 2)]
if (der == 0):
funcs = [(lambda x: ((x * x) / 2.0)), (lambda x: ((3.0 / 4) - ((x - (3.0 / 2)) ** 2))), (lambda x: (((3.0 - x) ** 2) / 2))]
elif (der == 2):
funcs = [(lambda x: 1.0), (lambda x: (-2.0)), (lambda x: 1.0)]
else:
raise ValueError(('never be here: der=%s' % der))
pieces = np.piecewise(x, conds, funcs)
return pieces
| [
"def",
"B_0123",
"(",
"x",
",",
"der",
"=",
"0",
")",
":",
"x",
"=",
"np",
".",
"atleast_1d",
"(",
"x",
")",
"conds",
"=",
"[",
"(",
"x",
"<",
"1",
")",
",",
"(",
"(",
"x",
">",
"1",
")",
"&",
"(",
"x",
"<",
"2",
")",
")",
",",
"(",
"x",
">",
"2",
")",
"]",
"if",
"(",
"der",
"==",
"0",
")",
":",
"funcs",
"=",
"[",
"(",
"lambda",
"x",
":",
"(",
"(",
"x",
"*",
"x",
")",
"/",
"2.0",
")",
")",
",",
"(",
"lambda",
"x",
":",
"(",
"(",
"3.0",
"/",
"4",
")",
"-",
"(",
"(",
"x",
"-",
"(",
"3.0",
"/",
"2",
")",
")",
"**",
"2",
")",
")",
")",
",",
"(",
"lambda",
"x",
":",
"(",
"(",
"(",
"3.0",
"-",
"x",
")",
"**",
"2",
")",
"/",
"2",
")",
")",
"]",
"elif",
"(",
"der",
"==",
"2",
")",
":",
"funcs",
"=",
"[",
"(",
"lambda",
"x",
":",
"1.0",
")",
",",
"(",
"lambda",
"x",
":",
"(",
"-",
"2.0",
")",
")",
",",
"(",
"lambda",
"x",
":",
"1.0",
")",
"]",
"else",
":",
"raise",
"ValueError",
"(",
"(",
"'never be here: der=%s'",
"%",
"der",
")",
")",
"pieces",
"=",
"np",
".",
"piecewise",
"(",
"x",
",",
"conds",
",",
"funcs",
")",
"return",
"pieces"
] | a quadratic b-spline function b . | train | false |
22,558 | @require_context
def pinned_array(shape, dtype=np.float, strides=None, order='C'):
(shape, strides, dtype) = _prepare_shape_strides_dtype(shape, strides, dtype, order)
bytesize = driver.memory_size_from_info(shape, strides, dtype.itemsize)
buffer = current_context().memhostalloc(bytesize)
return np.ndarray(shape=shape, strides=strides, dtype=dtype, order=order, buffer=buffer)
| [
"@",
"require_context",
"def",
"pinned_array",
"(",
"shape",
",",
"dtype",
"=",
"np",
".",
"float",
",",
"strides",
"=",
"None",
",",
"order",
"=",
"'C'",
")",
":",
"(",
"shape",
",",
"strides",
",",
"dtype",
")",
"=",
"_prepare_shape_strides_dtype",
"(",
"shape",
",",
"strides",
",",
"dtype",
",",
"order",
")",
"bytesize",
"=",
"driver",
".",
"memory_size_from_info",
"(",
"shape",
",",
"strides",
",",
"dtype",
".",
"itemsize",
")",
"buffer",
"=",
"current_context",
"(",
")",
".",
"memhostalloc",
"(",
"bytesize",
")",
"return",
"np",
".",
"ndarray",
"(",
"shape",
"=",
"shape",
",",
"strides",
"=",
"strides",
",",
"dtype",
"=",
"dtype",
",",
"order",
"=",
"order",
",",
"buffer",
"=",
"buffer",
")"
] | pinned_array allocate a np . | train | false |
22,559 | def getRepositoryText(repository):
repositoryWriter = getRepositoryWriter(repository.title.lower())
for setting in repository.preferences:
setting.writeToRepositoryWriter(repositoryWriter)
return repositoryWriter.getvalue()
| [
"def",
"getRepositoryText",
"(",
"repository",
")",
":",
"repositoryWriter",
"=",
"getRepositoryWriter",
"(",
"repository",
".",
"title",
".",
"lower",
"(",
")",
")",
"for",
"setting",
"in",
"repository",
".",
"preferences",
":",
"setting",
".",
"writeToRepositoryWriter",
"(",
"repositoryWriter",
")",
"return",
"repositoryWriter",
".",
"getvalue",
"(",
")"
] | get the text representation of the repository . | train | false |
22,563 | def given(expr, condition=None, **kwargs):
if ((not random_symbols(condition)) or pspace_independent(expr, condition)):
return expr
if isinstance(condition, RandomSymbol):
condition = Eq(condition, condition.symbol)
condsymbols = random_symbols(condition)
if (isinstance(condition, Equality) and (len(condsymbols) == 1) and (not isinstance(pspace(expr).domain, ConditionalDomain))):
rv = tuple(condsymbols)[0]
results = solveset(condition, rv)
if (isinstance(results, Intersection) and (S.Reals in results.args)):
results = list(results.args[1])
return sum((expr.subs(rv, res) for res in results))
fullspace = pspace(Tuple(expr, condition))
space = fullspace.conditional_space(condition, **kwargs)
swapdict = rs_swap(fullspace.values, space.values)
expr = expr.xreplace(swapdict)
return expr
| [
"def",
"given",
"(",
"expr",
",",
"condition",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"if",
"(",
"(",
"not",
"random_symbols",
"(",
"condition",
")",
")",
"or",
"pspace_independent",
"(",
"expr",
",",
"condition",
")",
")",
":",
"return",
"expr",
"if",
"isinstance",
"(",
"condition",
",",
"RandomSymbol",
")",
":",
"condition",
"=",
"Eq",
"(",
"condition",
",",
"condition",
".",
"symbol",
")",
"condsymbols",
"=",
"random_symbols",
"(",
"condition",
")",
"if",
"(",
"isinstance",
"(",
"condition",
",",
"Equality",
")",
"and",
"(",
"len",
"(",
"condsymbols",
")",
"==",
"1",
")",
"and",
"(",
"not",
"isinstance",
"(",
"pspace",
"(",
"expr",
")",
".",
"domain",
",",
"ConditionalDomain",
")",
")",
")",
":",
"rv",
"=",
"tuple",
"(",
"condsymbols",
")",
"[",
"0",
"]",
"results",
"=",
"solveset",
"(",
"condition",
",",
"rv",
")",
"if",
"(",
"isinstance",
"(",
"results",
",",
"Intersection",
")",
"and",
"(",
"S",
".",
"Reals",
"in",
"results",
".",
"args",
")",
")",
":",
"results",
"=",
"list",
"(",
"results",
".",
"args",
"[",
"1",
"]",
")",
"return",
"sum",
"(",
"(",
"expr",
".",
"subs",
"(",
"rv",
",",
"res",
")",
"for",
"res",
"in",
"results",
")",
")",
"fullspace",
"=",
"pspace",
"(",
"Tuple",
"(",
"expr",
",",
"condition",
")",
")",
"space",
"=",
"fullspace",
".",
"conditional_space",
"(",
"condition",
",",
"**",
"kwargs",
")",
"swapdict",
"=",
"rs_swap",
"(",
"fullspace",
".",
"values",
",",
"space",
".",
"values",
")",
"expr",
"=",
"expr",
".",
"xreplace",
"(",
"swapdict",
")",
"return",
"expr"
] | conditional random expression from a random expression and a condition on that expression creates a new probability space from the condition and returns the same expression on that conditional probability space . | train | false |
22,564 | @register.function
@jinja2.contextfunction
def queue_tabnav_themes(context):
tabs = []
if acl.action_allowed(context['request'], 'Personas', 'Review'):
tabs.append(('editors.themes.list', 'pending_themes', _('Pending')))
if acl.action_allowed(context['request'], 'SeniorPersonasTools', 'View'):
tabs.append(('editors.themes.list_flagged', 'flagged_themes', _('Flagged')))
tabs.append(('editors.themes.list_rereview', 'rereview_themes', _('Updates')))
return tabs
| [
"@",
"register",
".",
"function",
"@",
"jinja2",
".",
"contextfunction",
"def",
"queue_tabnav_themes",
"(",
"context",
")",
":",
"tabs",
"=",
"[",
"]",
"if",
"acl",
".",
"action_allowed",
"(",
"context",
"[",
"'request'",
"]",
",",
"'Personas'",
",",
"'Review'",
")",
":",
"tabs",
".",
"append",
"(",
"(",
"'editors.themes.list'",
",",
"'pending_themes'",
",",
"_",
"(",
"'Pending'",
")",
")",
")",
"if",
"acl",
".",
"action_allowed",
"(",
"context",
"[",
"'request'",
"]",
",",
"'SeniorPersonasTools'",
",",
"'View'",
")",
":",
"tabs",
".",
"append",
"(",
"(",
"'editors.themes.list_flagged'",
",",
"'flagged_themes'",
",",
"_",
"(",
"'Flagged'",
")",
")",
")",
"tabs",
".",
"append",
"(",
"(",
"'editors.themes.list_rereview'",
",",
"'rereview_themes'",
",",
"_",
"(",
"'Updates'",
")",
")",
")",
"return",
"tabs"
] | similar to queue_tabnav . | train | false |
22,565 | def hdmi_force_hotplug_config_set(kodi_setting, all_settings):
if (kodi_setting == 'true'):
return '1'
elif (all_settings.get('hdmi_edid_file', None) == 'true'):
return '1'
else:
return 'remove_this_line'
| [
"def",
"hdmi_force_hotplug_config_set",
"(",
"kodi_setting",
",",
"all_settings",
")",
":",
"if",
"(",
"kodi_setting",
"==",
"'true'",
")",
":",
"return",
"'1'",
"elif",
"(",
"all_settings",
".",
"get",
"(",
"'hdmi_edid_file'",
",",
"None",
")",
"==",
"'true'",
")",
":",
"return",
"'1'",
"else",
":",
"return",
"'remove_this_line'"
] | hdmi_edid_file needs hdmi_force_hotplug but hdmi_force_hotplug doesnt need hdmi_edid_file . | train | false |
22,566 | def get_zonecode():
return False
| [
"def",
"get_zonecode",
"(",
")",
":",
"return",
"False"
] | get current timezone cli example: . | train | false |
22,567 | def repeat_call_proxy_for(interface, provider):
return proxyForInterface(interface, originalAttribute='_original')(_RepeatProxy(_provider=provider))
| [
"def",
"repeat_call_proxy_for",
"(",
"interface",
",",
"provider",
")",
":",
"return",
"proxyForInterface",
"(",
"interface",
",",
"originalAttribute",
"=",
"'_original'",
")",
"(",
"_RepeatProxy",
"(",
"_provider",
"=",
"provider",
")",
")"
] | constructs an implementation of interface that calls the corresponding method on implementation twice for every call to a method . | train | false |
22,568 | def set_inactdays(name, days):
return False
| [
"def",
"set_inactdays",
"(",
"name",
",",
"days",
")",
":",
"return",
"False"
] | set the number of days of inactivity after a password has expired before the account is locked . | train | false |
22,569 | def get_quote(code, data, name):
if (code in data):
return (name, data[code])
return (name, data[u'ALL'])
| [
"def",
"get_quote",
"(",
"code",
",",
"data",
",",
"name",
")",
":",
"if",
"(",
"code",
"in",
"data",
")",
":",
"return",
"(",
"name",
",",
"data",
"[",
"code",
"]",
")",
"return",
"(",
"name",
",",
"data",
"[",
"u'ALL'",
"]",
")"
] | returns special char for quote . | train | false |
22,570 | @app.route('/account/<subscription_id>/resourcegroups/<resource_group_name>/storageaccounts/<account_name>')
@auth.require_login
def storageaccount_view(subscription_id, resource_group_name, account_name):
creds = _get_credentials()
model = models.get_storage_account_details(subscription_id, creds, resource_group_name, account_name)
return render_template('storageaccount.html', title=account_name, year=datetime.now().year, subscription_id=subscription_id, resource_group_name=resource_group_name, model=model)
| [
"@",
"app",
".",
"route",
"(",
"'/account/<subscription_id>/resourcegroups/<resource_group_name>/storageaccounts/<account_name>'",
")",
"@",
"auth",
".",
"require_login",
"def",
"storageaccount_view",
"(",
"subscription_id",
",",
"resource_group_name",
",",
"account_name",
")",
":",
"creds",
"=",
"_get_credentials",
"(",
")",
"model",
"=",
"models",
".",
"get_storage_account_details",
"(",
"subscription_id",
",",
"creds",
",",
"resource_group_name",
",",
"account_name",
")",
"return",
"render_template",
"(",
"'storageaccount.html'",
",",
"title",
"=",
"account_name",
",",
"year",
"=",
"datetime",
".",
"now",
"(",
")",
".",
"year",
",",
"subscription_id",
"=",
"subscription_id",
",",
"resource_group_name",
"=",
"resource_group_name",
",",
"model",
"=",
"model",
")"
] | renders the storage account details . | train | false |
22,573 | def add_volume_bricks(name, bricks):
ret = {'name': name, 'changes': {}, 'comment': '', 'result': False}
volinfo = __salt__['glusterfs.info']()
if (name not in volinfo):
ret['comment'] = 'Volume {0} does not exist'.format(name)
return ret
if (int(volinfo[name]['status']) != 1):
ret['comment'] = 'Volume {0} is not started'.format(name)
return ret
current_bricks = [brick['path'] for brick in volinfo[name]['bricks'].values()]
if (not (set(bricks) - set(current_bricks))):
ret['result'] = True
ret['comment'] = 'Bricks already added in volume {0}'.format(name)
return ret
bricks_added = __salt__['glusterfs.add_volume_bricks'](name, bricks)
if bricks_added:
ret['result'] = True
ret['comment'] = 'Bricks successfully added to volume {0}'.format(name)
new_bricks = [brick['path'] for brick in __salt__['glusterfs.info']()[name]['bricks'].values()]
ret['changes'] = {'new': new_bricks, 'old': current_bricks}
return ret
ret['comment'] = 'Adding bricks to volume {0} failed'.format(name)
return ret
| [
"def",
"add_volume_bricks",
"(",
"name",
",",
"bricks",
")",
":",
"ret",
"=",
"{",
"'name'",
":",
"name",
",",
"'changes'",
":",
"{",
"}",
",",
"'comment'",
":",
"''",
",",
"'result'",
":",
"False",
"}",
"volinfo",
"=",
"__salt__",
"[",
"'glusterfs.info'",
"]",
"(",
")",
"if",
"(",
"name",
"not",
"in",
"volinfo",
")",
":",
"ret",
"[",
"'comment'",
"]",
"=",
"'Volume {0} does not exist'",
".",
"format",
"(",
"name",
")",
"return",
"ret",
"if",
"(",
"int",
"(",
"volinfo",
"[",
"name",
"]",
"[",
"'status'",
"]",
")",
"!=",
"1",
")",
":",
"ret",
"[",
"'comment'",
"]",
"=",
"'Volume {0} is not started'",
".",
"format",
"(",
"name",
")",
"return",
"ret",
"current_bricks",
"=",
"[",
"brick",
"[",
"'path'",
"]",
"for",
"brick",
"in",
"volinfo",
"[",
"name",
"]",
"[",
"'bricks'",
"]",
".",
"values",
"(",
")",
"]",
"if",
"(",
"not",
"(",
"set",
"(",
"bricks",
")",
"-",
"set",
"(",
"current_bricks",
")",
")",
")",
":",
"ret",
"[",
"'result'",
"]",
"=",
"True",
"ret",
"[",
"'comment'",
"]",
"=",
"'Bricks already added in volume {0}'",
".",
"format",
"(",
"name",
")",
"return",
"ret",
"bricks_added",
"=",
"__salt__",
"[",
"'glusterfs.add_volume_bricks'",
"]",
"(",
"name",
",",
"bricks",
")",
"if",
"bricks_added",
":",
"ret",
"[",
"'result'",
"]",
"=",
"True",
"ret",
"[",
"'comment'",
"]",
"=",
"'Bricks successfully added to volume {0}'",
".",
"format",
"(",
"name",
")",
"new_bricks",
"=",
"[",
"brick",
"[",
"'path'",
"]",
"for",
"brick",
"in",
"__salt__",
"[",
"'glusterfs.info'",
"]",
"(",
")",
"[",
"name",
"]",
"[",
"'bricks'",
"]",
".",
"values",
"(",
")",
"]",
"ret",
"[",
"'changes'",
"]",
"=",
"{",
"'new'",
":",
"new_bricks",
",",
"'old'",
":",
"current_bricks",
"}",
"return",
"ret",
"ret",
"[",
"'comment'",
"]",
"=",
"'Adding bricks to volume {0} failed'",
".",
"format",
"(",
"name",
")",
"return",
"ret"
] | add brick(s) to an existing volume name volume name bricks list of bricks to add to the volume . | train | true |
22,574 | @docstring.dedent_interpd
def mark_inset(parent_axes, inset_axes, loc1, loc2, **kwargs):
rect = TransformedBbox(inset_axes.viewLim, parent_axes.transData)
pp = BboxPatch(rect, fill=False, **kwargs)
parent_axes.add_patch(pp)
p1 = BboxConnector(inset_axes.bbox, rect, loc1=loc1, **kwargs)
inset_axes.add_patch(p1)
p1.set_clip_on(False)
p2 = BboxConnector(inset_axes.bbox, rect, loc1=loc2, **kwargs)
inset_axes.add_patch(p2)
p2.set_clip_on(False)
return (pp, p1, p2)
| [
"@",
"docstring",
".",
"dedent_interpd",
"def",
"mark_inset",
"(",
"parent_axes",
",",
"inset_axes",
",",
"loc1",
",",
"loc2",
",",
"**",
"kwargs",
")",
":",
"rect",
"=",
"TransformedBbox",
"(",
"inset_axes",
".",
"viewLim",
",",
"parent_axes",
".",
"transData",
")",
"pp",
"=",
"BboxPatch",
"(",
"rect",
",",
"fill",
"=",
"False",
",",
"**",
"kwargs",
")",
"parent_axes",
".",
"add_patch",
"(",
"pp",
")",
"p1",
"=",
"BboxConnector",
"(",
"inset_axes",
".",
"bbox",
",",
"rect",
",",
"loc1",
"=",
"loc1",
",",
"**",
"kwargs",
")",
"inset_axes",
".",
"add_patch",
"(",
"p1",
")",
"p1",
".",
"set_clip_on",
"(",
"False",
")",
"p2",
"=",
"BboxConnector",
"(",
"inset_axes",
".",
"bbox",
",",
"rect",
",",
"loc1",
"=",
"loc2",
",",
"**",
"kwargs",
")",
"inset_axes",
".",
"add_patch",
"(",
"p2",
")",
"p2",
".",
"set_clip_on",
"(",
"False",
")",
"return",
"(",
"pp",
",",
"p1",
",",
"p2",
")"
] | draw a box to mark the location of an area represented by an inset axes . | train | false |
22,576 | def isDefaultHandler():
return (signal.getsignal(signal.SIGCHLD) == signal.SIG_DFL)
| [
"def",
"isDefaultHandler",
"(",
")",
":",
"return",
"(",
"signal",
".",
"getsignal",
"(",
"signal",
".",
"SIGCHLD",
")",
"==",
"signal",
".",
"SIG_DFL",
")"
] | determine whether the i{sigchld} handler is the default or not . | train | false |
22,577 | def net_recv_object(sock, timeout=60):
try:
endtime = (time.time() + timeout)
data = ''
d_len = int(sock.recv(10))
while (len(data) < d_len):
sock.settimeout((endtime - time.time()))
data += sock.recv((d_len - len(data)))
data = pickle.loads(data)
return data
except (socket.timeout, ValueError) as e:
raise error.NetCommunicationError('Failed to receive python object over the network.')
| [
"def",
"net_recv_object",
"(",
"sock",
",",
"timeout",
"=",
"60",
")",
":",
"try",
":",
"endtime",
"=",
"(",
"time",
".",
"time",
"(",
")",
"+",
"timeout",
")",
"data",
"=",
"''",
"d_len",
"=",
"int",
"(",
"sock",
".",
"recv",
"(",
"10",
")",
")",
"while",
"(",
"len",
"(",
"data",
")",
"<",
"d_len",
")",
":",
"sock",
".",
"settimeout",
"(",
"(",
"endtime",
"-",
"time",
".",
"time",
"(",
")",
")",
")",
"data",
"+=",
"sock",
".",
"recv",
"(",
"(",
"d_len",
"-",
"len",
"(",
"data",
")",
")",
")",
"data",
"=",
"pickle",
".",
"loads",
"(",
"data",
")",
"return",
"data",
"except",
"(",
"socket",
".",
"timeout",
",",
"ValueError",
")",
"as",
"e",
":",
"raise",
"error",
".",
"NetCommunicationError",
"(",
"'Failed to receive python object over the network.'",
")"
] | receive python object over network . | train | false |
22,580 | @require_GET
@ensure_csrf_cookie
@login_required
@ensure_valid_course_key
def import_status_handler(request, course_key_string, filename=None):
course_key = CourseKey.from_string(course_key_string)
if (not has_course_author_access(request.user, course_key)):
raise PermissionDenied()
try:
session_status = request.session['import_status']
status = session_status[(course_key_string + filename)]
except KeyError:
status = 0
return JsonResponse({'ImportStatus': status})
| [
"@",
"require_GET",
"@",
"ensure_csrf_cookie",
"@",
"login_required",
"@",
"ensure_valid_course_key",
"def",
"import_status_handler",
"(",
"request",
",",
"course_key_string",
",",
"filename",
"=",
"None",
")",
":",
"course_key",
"=",
"CourseKey",
".",
"from_string",
"(",
"course_key_string",
")",
"if",
"(",
"not",
"has_course_author_access",
"(",
"request",
".",
"user",
",",
"course_key",
")",
")",
":",
"raise",
"PermissionDenied",
"(",
")",
"try",
":",
"session_status",
"=",
"request",
".",
"session",
"[",
"'import_status'",
"]",
"status",
"=",
"session_status",
"[",
"(",
"course_key_string",
"+",
"filename",
")",
"]",
"except",
"KeyError",
":",
"status",
"=",
"0",
"return",
"JsonResponse",
"(",
"{",
"'ImportStatus'",
":",
"status",
"}",
")"
] | returns an integer corresponding to the status of a file import . | train | false |
22,581 | def Lagrangian(frame, *body):
if (not isinstance(frame, ReferenceFrame)):
raise TypeError('Please supply a valid ReferenceFrame')
for e in body:
if (not isinstance(e, (RigidBody, Particle))):
raise TypeError('*body must have only Particle or RigidBody')
return (kinetic_energy(frame, *body) - potential_energy(*body))
| [
"def",
"Lagrangian",
"(",
"frame",
",",
"*",
"body",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"frame",
",",
"ReferenceFrame",
")",
")",
":",
"raise",
"TypeError",
"(",
"'Please supply a valid ReferenceFrame'",
")",
"for",
"e",
"in",
"body",
":",
"if",
"(",
"not",
"isinstance",
"(",
"e",
",",
"(",
"RigidBody",
",",
"Particle",
")",
")",
")",
":",
"raise",
"TypeError",
"(",
"'*body must have only Particle or RigidBody'",
")",
"return",
"(",
"kinetic_energy",
"(",
"frame",
",",
"*",
"body",
")",
"-",
"potential_energy",
"(",
"*",
"body",
")",
")"
] | lagrangian of a multibody system . | train | false |
22,582 | def _root_broyden2_doc():
pass
| [
"def",
"_root_broyden2_doc",
"(",
")",
":",
"pass"
] | options nit : int . | train | false |
22,583 | def _collect_post_update_commands(base_mapper, uowtransaction, table, states_to_update, post_update_cols):
update = []
for (state, state_dict, mapper, connection) in states_to_update:
if (table not in mapper._pks_by_table):
continue
pks = mapper._pks_by_table[table]
params = {}
hasdata = False
for col in mapper._cols_by_table[table]:
if (col in pks):
params[col._label] = mapper._get_state_attr_by_column(state, state_dict, col)
elif (col in post_update_cols):
prop = mapper._columntoproperty[col]
history = attributes.get_state_history(state, prop.key, attributes.PASSIVE_NO_INITIALIZE)
if history.added:
value = history.added[0]
params[col.key] = value
hasdata = True
if hasdata:
update.append((state, state_dict, params, mapper, connection))
return update
| [
"def",
"_collect_post_update_commands",
"(",
"base_mapper",
",",
"uowtransaction",
",",
"table",
",",
"states_to_update",
",",
"post_update_cols",
")",
":",
"update",
"=",
"[",
"]",
"for",
"(",
"state",
",",
"state_dict",
",",
"mapper",
",",
"connection",
")",
"in",
"states_to_update",
":",
"if",
"(",
"table",
"not",
"in",
"mapper",
".",
"_pks_by_table",
")",
":",
"continue",
"pks",
"=",
"mapper",
".",
"_pks_by_table",
"[",
"table",
"]",
"params",
"=",
"{",
"}",
"hasdata",
"=",
"False",
"for",
"col",
"in",
"mapper",
".",
"_cols_by_table",
"[",
"table",
"]",
":",
"if",
"(",
"col",
"in",
"pks",
")",
":",
"params",
"[",
"col",
".",
"_label",
"]",
"=",
"mapper",
".",
"_get_state_attr_by_column",
"(",
"state",
",",
"state_dict",
",",
"col",
")",
"elif",
"(",
"col",
"in",
"post_update_cols",
")",
":",
"prop",
"=",
"mapper",
".",
"_columntoproperty",
"[",
"col",
"]",
"history",
"=",
"attributes",
".",
"get_state_history",
"(",
"state",
",",
"prop",
".",
"key",
",",
"attributes",
".",
"PASSIVE_NO_INITIALIZE",
")",
"if",
"history",
".",
"added",
":",
"value",
"=",
"history",
".",
"added",
"[",
"0",
"]",
"params",
"[",
"col",
".",
"key",
"]",
"=",
"value",
"hasdata",
"=",
"True",
"if",
"hasdata",
":",
"update",
".",
"append",
"(",
"(",
"state",
",",
"state_dict",
",",
"params",
",",
"mapper",
",",
"connection",
")",
")",
"return",
"update"
] | identify sets of values to use in update statements for a list of states within a post_update operation . | train | false |
22,584 | def ar2full(ar):
(nlags, nvar, nvarex) = ar.shape
return np.r_[(np.eye(nvar, nvarex)[None, :, :], (- ar))]
| [
"def",
"ar2full",
"(",
"ar",
")",
":",
"(",
"nlags",
",",
"nvar",
",",
"nvarex",
")",
"=",
"ar",
".",
"shape",
"return",
"np",
".",
"r_",
"[",
"(",
"np",
".",
"eye",
"(",
"nvar",
",",
"nvarex",
")",
"[",
"None",
",",
":",
",",
":",
"]",
",",
"(",
"-",
"ar",
")",
")",
"]"
] | make reduced lagpolynomial into a right side lagpoly array . | train | false |
22,585 | def sdm_to_dict(f):
return dict(f)
| [
"def",
"sdm_to_dict",
"(",
"f",
")",
":",
"return",
"dict",
"(",
"f",
")"
] | make a dictionary from a distributed polynomial . | train | false |
22,586 | def addPathIndexFirstSegment(gridPixel, pathIndexTable, pixelTable, segmentFirstPixel):
for yStep in xrange(gridPixel[1], (segmentFirstPixel[1] - 1), (-1)):
if getKeyIsInPixelTableAddValue((gridPixel[0], yStep), pathIndexTable, pixelTable):
return
| [
"def",
"addPathIndexFirstSegment",
"(",
"gridPixel",
",",
"pathIndexTable",
",",
"pixelTable",
",",
"segmentFirstPixel",
")",
":",
"for",
"yStep",
"in",
"xrange",
"(",
"gridPixel",
"[",
"1",
"]",
",",
"(",
"segmentFirstPixel",
"[",
"1",
"]",
"-",
"1",
")",
",",
"(",
"-",
"1",
")",
")",
":",
"if",
"getKeyIsInPixelTableAddValue",
"(",
"(",
"gridPixel",
"[",
"0",
"]",
",",
"yStep",
")",
",",
"pathIndexTable",
",",
"pixelTable",
")",
":",
"return"
] | add the path index of the closest segment found toward the second segment . | train | false |
22,587 | @dispatch(sa.sql.elements.Label)
def get_inner_columns(label):
name = label.name
inner_columns = get_inner_columns(label.element)
assert (len(inner_columns) == 1)
return [lower_column(c).label(name) for c in inner_columns]
| [
"@",
"dispatch",
"(",
"sa",
".",
"sql",
".",
"elements",
".",
"Label",
")",
"def",
"get_inner_columns",
"(",
"label",
")",
":",
"name",
"=",
"label",
".",
"name",
"inner_columns",
"=",
"get_inner_columns",
"(",
"label",
".",
"element",
")",
"assert",
"(",
"len",
"(",
"inner_columns",
")",
"==",
"1",
")",
"return",
"[",
"lower_column",
"(",
"c",
")",
".",
"label",
"(",
"name",
")",
"for",
"c",
"in",
"inner_columns",
"]"
] | notes this should only ever return a list of length 1 this is because we need to turn scalarselects into an actual column . | train | false |
22,588 | def get_own_memusage_linux():
with open(('/proc/%d/status' % os.getpid()), 'r') as f:
procdata = f.read()
m = re.search('VmRSS:\\s*(\\d+)\\s*kB', procdata, (re.S | re.I))
if (m is not None):
memusage = (float(m.group(1)) * 1000.0)
return memusage
return np.nan
| [
"def",
"get_own_memusage_linux",
"(",
")",
":",
"with",
"open",
"(",
"(",
"'/proc/%d/status'",
"%",
"os",
".",
"getpid",
"(",
")",
")",
",",
"'r'",
")",
"as",
"f",
":",
"procdata",
"=",
"f",
".",
"read",
"(",
")",
"m",
"=",
"re",
".",
"search",
"(",
"'VmRSS:\\\\s*(\\\\d+)\\\\s*kB'",
",",
"procdata",
",",
"(",
"re",
".",
"S",
"|",
"re",
".",
"I",
")",
")",
"if",
"(",
"m",
"is",
"not",
"None",
")",
":",
"memusage",
"=",
"(",
"float",
"(",
"m",
".",
"group",
"(",
"1",
")",
")",
"*",
"1000.0",
")",
"return",
"memusage",
"return",
"np",
".",
"nan"
] | return the memory usage of the current process . | train | false |
22,589 | @click.command(u'destroy-all-sessions')
@click.option(u'--reason')
@pass_context
def destroy_all_sessions(context, reason=None):
import frappe.sessions
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
frappe.sessions.clear_all_sessions(reason)
frappe.db.commit()
finally:
frappe.destroy()
| [
"@",
"click",
".",
"command",
"(",
"u'destroy-all-sessions'",
")",
"@",
"click",
".",
"option",
"(",
"u'--reason'",
")",
"@",
"pass_context",
"def",
"destroy_all_sessions",
"(",
"context",
",",
"reason",
"=",
"None",
")",
":",
"import",
"frappe",
".",
"sessions",
"for",
"site",
"in",
"context",
".",
"sites",
":",
"try",
":",
"frappe",
".",
"init",
"(",
"site",
"=",
"site",
")",
"frappe",
".",
"connect",
"(",
")",
"frappe",
".",
"sessions",
".",
"clear_all_sessions",
"(",
"reason",
")",
"frappe",
".",
"db",
".",
"commit",
"(",
")",
"finally",
":",
"frappe",
".",
"destroy",
"(",
")"
] | clear sessions of all users . | train | false |
22,590 | @not_implemented_for('directed')
def to_nested_tuple(T, root, canonical_form=False):
def _make_tuple(T, root, _parent):
'Recursively compute the nested tuple representation of the\n given rooted tree.\n\n ``_parent`` is the parent node of ``root`` in the supertree in\n which ``T`` is a subtree, or ``None`` if ``root`` is the root of\n the supertree. This argument is used to determine which\n neighbors of ``root`` are children and which is the parent.\n\n '
children = (set(T[root]) - {_parent})
if (len(children) == 0):
return ()
nested = (_make_tuple(T, v, root) for v in children)
if canonical_form:
nested = sorted(nested)
return tuple(nested)
if (not nx.is_tree(T)):
raise nx.NotATree('provided graph is not a tree')
if (root not in T):
raise nx.NodeNotFound('Graph {} contains no node {}'.format(T, root))
return _make_tuple(T, root, None)
| [
"@",
"not_implemented_for",
"(",
"'directed'",
")",
"def",
"to_nested_tuple",
"(",
"T",
",",
"root",
",",
"canonical_form",
"=",
"False",
")",
":",
"def",
"_make_tuple",
"(",
"T",
",",
"root",
",",
"_parent",
")",
":",
"children",
"=",
"(",
"set",
"(",
"T",
"[",
"root",
"]",
")",
"-",
"{",
"_parent",
"}",
")",
"if",
"(",
"len",
"(",
"children",
")",
"==",
"0",
")",
":",
"return",
"(",
")",
"nested",
"=",
"(",
"_make_tuple",
"(",
"T",
",",
"v",
",",
"root",
")",
"for",
"v",
"in",
"children",
")",
"if",
"canonical_form",
":",
"nested",
"=",
"sorted",
"(",
"nested",
")",
"return",
"tuple",
"(",
"nested",
")",
"if",
"(",
"not",
"nx",
".",
"is_tree",
"(",
"T",
")",
")",
":",
"raise",
"nx",
".",
"NotATree",
"(",
"'provided graph is not a tree'",
")",
"if",
"(",
"root",
"not",
"in",
"T",
")",
":",
"raise",
"nx",
".",
"NodeNotFound",
"(",
"'Graph {} contains no node {}'",
".",
"format",
"(",
"T",
",",
"root",
")",
")",
"return",
"_make_tuple",
"(",
"T",
",",
"root",
",",
"None",
")"
] | returns a nested tuple representation of the given tree . | train | false |
22,593 | def iter_docstring_info(dir_name):
for file_info in iter_filename_info(dir_name):
if ('error' in file_info):
Logger.error(file_info['error'])
continue
source = slash(examples_dir, file_info['dir'], ((file_info['file'] + '.') + file_info['ext']))
if (not os.path.exists(source)):
Logger.error('Screen shot references source code that does not exist: %s', source)
continue
with open(source) as f:
text = f.read()
docstring_info = parse_docstring_info(text)
if ('error' in docstring_info):
Logger.error(((docstring_info['error'] + ' File: ') + source))
continue
else:
file_info.update(docstring_info)
(yield file_info)
| [
"def",
"iter_docstring_info",
"(",
"dir_name",
")",
":",
"for",
"file_info",
"in",
"iter_filename_info",
"(",
"dir_name",
")",
":",
"if",
"(",
"'error'",
"in",
"file_info",
")",
":",
"Logger",
".",
"error",
"(",
"file_info",
"[",
"'error'",
"]",
")",
"continue",
"source",
"=",
"slash",
"(",
"examples_dir",
",",
"file_info",
"[",
"'dir'",
"]",
",",
"(",
"(",
"file_info",
"[",
"'file'",
"]",
"+",
"'.'",
")",
"+",
"file_info",
"[",
"'ext'",
"]",
")",
")",
"if",
"(",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"source",
")",
")",
":",
"Logger",
".",
"error",
"(",
"'Screen shot references source code that does not exist: %s'",
",",
"source",
")",
"continue",
"with",
"open",
"(",
"source",
")",
"as",
"f",
":",
"text",
"=",
"f",
".",
"read",
"(",
")",
"docstring_info",
"=",
"parse_docstring_info",
"(",
"text",
")",
"if",
"(",
"'error'",
"in",
"docstring_info",
")",
":",
"Logger",
".",
"error",
"(",
"(",
"(",
"docstring_info",
"[",
"'error'",
"]",
"+",
"' File: '",
")",
"+",
"source",
")",
")",
"continue",
"else",
":",
"file_info",
".",
"update",
"(",
"docstring_info",
")",
"(",
"yield",
"file_info",
")"
] | iterate over screenshots in directory . | train | false |
22,594 | def _OpenFileInSplitIfNeeded(filepath):
buffer_num = GetBufferNumberForFilename(filepath, False)
if BufferIsVisible(buffer_num):
return (buffer_num, False)
OpenFilename(filepath, {u'focus': True, u'fix': True, u'size': GetIntValue(u'&previewheight')})
buffer_num = GetBufferNumberForFilename(filepath, False)
if (not BufferIsVisible(buffer_num)):
raise RuntimeError(u'Unable to open file: {0}\nFixIt/Refactor operation aborted prior to completion. Your files have not been fully updated. Please use undo commands to revert the applied changes.'.format(filepath))
return (buffer_num, True)
| [
"def",
"_OpenFileInSplitIfNeeded",
"(",
"filepath",
")",
":",
"buffer_num",
"=",
"GetBufferNumberForFilename",
"(",
"filepath",
",",
"False",
")",
"if",
"BufferIsVisible",
"(",
"buffer_num",
")",
":",
"return",
"(",
"buffer_num",
",",
"False",
")",
"OpenFilename",
"(",
"filepath",
",",
"{",
"u'focus'",
":",
"True",
",",
"u'fix'",
":",
"True",
",",
"u'size'",
":",
"GetIntValue",
"(",
"u'&previewheight'",
")",
"}",
")",
"buffer_num",
"=",
"GetBufferNumberForFilename",
"(",
"filepath",
",",
"False",
")",
"if",
"(",
"not",
"BufferIsVisible",
"(",
"buffer_num",
")",
")",
":",
"raise",
"RuntimeError",
"(",
"u'Unable to open file: {0}\\nFixIt/Refactor operation aborted prior to completion. Your files have not been fully updated. Please use undo commands to revert the applied changes.'",
".",
"format",
"(",
"filepath",
")",
")",
"return",
"(",
"buffer_num",
",",
"True",
")"
] | ensure that the supplied filepath is open in a visible window . | train | false |
22,595 | def hmason():
exec random.choice(re.findall('def (.*):', socode_source))
| [
"def",
"hmason",
"(",
")",
":",
"exec",
"random",
".",
"choice",
"(",
"re",
".",
"findall",
"(",
"'def (.*):'",
",",
"socode_source",
")",
")"
] | introduce randomness . | train | false |
22,596 | def is_weight(w):
if isinstance(w, np.ndarray):
w = w.tolist()
valid_elems = all((((v >= 0) and isinstance(v, (numbers.Integral, Fraction))) for v in w))
return (valid_elems and (sum(w) == 1))
| [
"def",
"is_weight",
"(",
"w",
")",
":",
"if",
"isinstance",
"(",
"w",
",",
"np",
".",
"ndarray",
")",
":",
"w",
"=",
"w",
".",
"tolist",
"(",
")",
"valid_elems",
"=",
"all",
"(",
"(",
"(",
"(",
"v",
">=",
"0",
")",
"and",
"isinstance",
"(",
"v",
",",
"(",
"numbers",
".",
"Integral",
",",
"Fraction",
")",
")",
")",
"for",
"v",
"in",
"w",
")",
")",
"return",
"(",
"valid_elems",
"and",
"(",
"sum",
"(",
"w",
")",
"==",
"1",
")",
")"
] | test if w is a valid weight vector . | train | false |
22,597 | def gen_arg_addrspace_md(fn):
mod = fn.module
fnty = fn.type.pointee
codes = []
for a in fnty.args:
if cgutils.is_pointer(a):
codes.append(SPIR_GLOBAL_ADDRSPACE)
else:
codes.append(SPIR_PRIVATE_ADDRSPACE)
consts = [lc.Constant.int(lc.Type.int(), x) for x in codes]
name = lc.MetaDataString.get(mod, 'kernel_arg_addr_space')
return lc.MetaData.get(mod, ([name] + consts))
| [
"def",
"gen_arg_addrspace_md",
"(",
"fn",
")",
":",
"mod",
"=",
"fn",
".",
"module",
"fnty",
"=",
"fn",
".",
"type",
".",
"pointee",
"codes",
"=",
"[",
"]",
"for",
"a",
"in",
"fnty",
".",
"args",
":",
"if",
"cgutils",
".",
"is_pointer",
"(",
"a",
")",
":",
"codes",
".",
"append",
"(",
"SPIR_GLOBAL_ADDRSPACE",
")",
"else",
":",
"codes",
".",
"append",
"(",
"SPIR_PRIVATE_ADDRSPACE",
")",
"consts",
"=",
"[",
"lc",
".",
"Constant",
".",
"int",
"(",
"lc",
".",
"Type",
".",
"int",
"(",
")",
",",
"x",
")",
"for",
"x",
"in",
"codes",
"]",
"name",
"=",
"lc",
".",
"MetaDataString",
".",
"get",
"(",
"mod",
",",
"'kernel_arg_addr_space'",
")",
"return",
"lc",
".",
"MetaData",
".",
"get",
"(",
"mod",
",",
"(",
"[",
"name",
"]",
"+",
"consts",
")",
")"
] | generate kernel_arg_addr_space metadata . | train | false |
22,598 | def get_placeholder_conf(setting, placeholder, template=None, default=None):
if placeholder:
keys = []
placeholder_conf = get_cms_setting('PLACEHOLDER_CONF')
if template:
keys.append((u'%s %s' % (template, placeholder)))
keys.append(placeholder)
if template:
keys.append(template)
keys.append(None)
for key in keys:
for (conf_key, conf) in placeholder_conf.items():
if (force_text(conf_key) == force_text(key)):
if (not conf):
continue
value = conf.get(setting)
if (value is not None):
return value
inherit = conf.get('inherit')
if inherit:
if (' ' in inherit):
inherit = inherit.split(' ')
else:
inherit = (None, inherit)
value = get_placeholder_conf(setting, inherit[1], inherit[0], default)
if (value is not None):
return value
return default
| [
"def",
"get_placeholder_conf",
"(",
"setting",
",",
"placeholder",
",",
"template",
"=",
"None",
",",
"default",
"=",
"None",
")",
":",
"if",
"placeholder",
":",
"keys",
"=",
"[",
"]",
"placeholder_conf",
"=",
"get_cms_setting",
"(",
"'PLACEHOLDER_CONF'",
")",
"if",
"template",
":",
"keys",
".",
"append",
"(",
"(",
"u'%s %s'",
"%",
"(",
"template",
",",
"placeholder",
")",
")",
")",
"keys",
".",
"append",
"(",
"placeholder",
")",
"if",
"template",
":",
"keys",
".",
"append",
"(",
"template",
")",
"keys",
".",
"append",
"(",
"None",
")",
"for",
"key",
"in",
"keys",
":",
"for",
"(",
"conf_key",
",",
"conf",
")",
"in",
"placeholder_conf",
".",
"items",
"(",
")",
":",
"if",
"(",
"force_text",
"(",
"conf_key",
")",
"==",
"force_text",
"(",
"key",
")",
")",
":",
"if",
"(",
"not",
"conf",
")",
":",
"continue",
"value",
"=",
"conf",
".",
"get",
"(",
"setting",
")",
"if",
"(",
"value",
"is",
"not",
"None",
")",
":",
"return",
"value",
"inherit",
"=",
"conf",
".",
"get",
"(",
"'inherit'",
")",
"if",
"inherit",
":",
"if",
"(",
"' '",
"in",
"inherit",
")",
":",
"inherit",
"=",
"inherit",
".",
"split",
"(",
"' '",
")",
"else",
":",
"inherit",
"=",
"(",
"None",
",",
"inherit",
")",
"value",
"=",
"get_placeholder_conf",
"(",
"setting",
",",
"inherit",
"[",
"1",
"]",
",",
"inherit",
"[",
"0",
"]",
",",
"default",
")",
"if",
"(",
"value",
"is",
"not",
"None",
")",
":",
"return",
"value",
"return",
"default"
] | returns the placeholder configuration for a given setting . | train | false |
22,599 | def _filter_attenuation(h, freq, gain):
from scipy.signal import freqd
(_, filt_resp) = freqd(h.ravel(), worN=(np.pi * freq))
filt_resp = np.abs(filt_resp)
filt_resp[np.where((gain == 1))] = 0
idx = np.argmax(filt_resp)
att_db = ((-20) * np.log10(np.maximum(filt_resp[idx], 1e-20)))
att_freq = freq[idx]
return (att_db, att_freq)
| [
"def",
"_filter_attenuation",
"(",
"h",
",",
"freq",
",",
"gain",
")",
":",
"from",
"scipy",
".",
"signal",
"import",
"freqd",
"(",
"_",
",",
"filt_resp",
")",
"=",
"freqd",
"(",
"h",
".",
"ravel",
"(",
")",
",",
"worN",
"=",
"(",
"np",
".",
"pi",
"*",
"freq",
")",
")",
"filt_resp",
"=",
"np",
".",
"abs",
"(",
"filt_resp",
")",
"filt_resp",
"[",
"np",
".",
"where",
"(",
"(",
"gain",
"==",
"1",
")",
")",
"]",
"=",
"0",
"idx",
"=",
"np",
".",
"argmax",
"(",
"filt_resp",
")",
"att_db",
"=",
"(",
"(",
"-",
"20",
")",
"*",
"np",
".",
"log10",
"(",
"np",
".",
"maximum",
"(",
"filt_resp",
"[",
"idx",
"]",
",",
"1e-20",
")",
")",
")",
"att_freq",
"=",
"freq",
"[",
"idx",
"]",
"return",
"(",
"att_db",
",",
"att_freq",
")"
] | compute minimum attenuation at stop frequency . | train | false |
22,600 | @handle_response_format
@treeio_login_required
def service_record_delete(request, service_record_id, response_format='html'):
service_record = get_object_or_404(ItemServicing, pk=service_record_id)
if (not request.user.profile.has_permission(service_record, mode='w')):
return user_denied(request, message="You don't have write access to this ServiceRecord")
if request.POST:
if ('delete' in request.POST):
if ('trash' in request.POST):
service_record.trash = True
service_record.save()
else:
service_record.delete()
return HttpResponseRedirect(reverse('infrastructure_settings_view'))
elif ('cancel' in request.POST):
return HttpResponseRedirect(reverse('infrastructure_service_record_view', args=[service_record.id]))
context = _get_default_context(request)
context.update({'service_record': service_record})
return render_to_response('infrastructure/service_record_delete', context, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"handle_response_format",
"@",
"treeio_login_required",
"def",
"service_record_delete",
"(",
"request",
",",
"service_record_id",
",",
"response_format",
"=",
"'html'",
")",
":",
"service_record",
"=",
"get_object_or_404",
"(",
"ItemServicing",
",",
"pk",
"=",
"service_record_id",
")",
"if",
"(",
"not",
"request",
".",
"user",
".",
"profile",
".",
"has_permission",
"(",
"service_record",
",",
"mode",
"=",
"'w'",
")",
")",
":",
"return",
"user_denied",
"(",
"request",
",",
"message",
"=",
"\"You don't have write access to this ServiceRecord\"",
")",
"if",
"request",
".",
"POST",
":",
"if",
"(",
"'delete'",
"in",
"request",
".",
"POST",
")",
":",
"if",
"(",
"'trash'",
"in",
"request",
".",
"POST",
")",
":",
"service_record",
".",
"trash",
"=",
"True",
"service_record",
".",
"save",
"(",
")",
"else",
":",
"service_record",
".",
"delete",
"(",
")",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'infrastructure_settings_view'",
")",
")",
"elif",
"(",
"'cancel'",
"in",
"request",
".",
"POST",
")",
":",
"return",
"HttpResponseRedirect",
"(",
"reverse",
"(",
"'infrastructure_service_record_view'",
",",
"args",
"=",
"[",
"service_record",
".",
"id",
"]",
")",
")",
"context",
"=",
"_get_default_context",
"(",
"request",
")",
"context",
".",
"update",
"(",
"{",
"'service_record'",
":",
"service_record",
"}",
")",
"return",
"render_to_response",
"(",
"'infrastructure/service_record_delete'",
",",
"context",
",",
"context_instance",
"=",
"RequestContext",
"(",
"request",
")",
",",
"response_format",
"=",
"response_format",
")"
] | servicerecord delete page . | train | false |
22,601 | def GenerateAuthSubUrl(next, scope, secure=False, session=True, request_url='https://www.google.com/accounts/AuthSubRequest', domain='default'):
if secure:
secure = 1
else:
secure = 0
if session:
session = 1
else:
session = 0
request_params = urllib.urlencode({'next': next, 'scope': scope, 'secure': secure, 'session': session, 'hd': domain})
if (request_url.find('?') == (-1)):
return ('%s?%s' % (request_url, request_params))
else:
return ('%s&%s' % (request_url, request_params))
| [
"def",
"GenerateAuthSubUrl",
"(",
"next",
",",
"scope",
",",
"secure",
"=",
"False",
",",
"session",
"=",
"True",
",",
"request_url",
"=",
"'https://www.google.com/accounts/AuthSubRequest'",
",",
"domain",
"=",
"'default'",
")",
":",
"if",
"secure",
":",
"secure",
"=",
"1",
"else",
":",
"secure",
"=",
"0",
"if",
"session",
":",
"session",
"=",
"1",
"else",
":",
"session",
"=",
"0",
"request_params",
"=",
"urllib",
".",
"urlencode",
"(",
"{",
"'next'",
":",
"next",
",",
"'scope'",
":",
"scope",
",",
"'secure'",
":",
"secure",
",",
"'session'",
":",
"session",
",",
"'hd'",
":",
"domain",
"}",
")",
"if",
"(",
"request_url",
".",
"find",
"(",
"'?'",
")",
"==",
"(",
"-",
"1",
")",
")",
":",
"return",
"(",
"'%s?%s'",
"%",
"(",
"request_url",
",",
"request_params",
")",
")",
"else",
":",
"return",
"(",
"'%s&%s'",
"%",
"(",
"request_url",
",",
"request_params",
")",
")"
] | generate a url at which the user will login and be redirected back . | train | false |
22,602 | def __remove_null_logging_handler():
global LOGGING_NULL_HANDLER
if (LOGGING_NULL_HANDLER is None):
return
root_logger = logging.getLogger()
for handler in root_logger.handlers:
if (handler is LOGGING_NULL_HANDLER):
root_logger.removeHandler(LOGGING_NULL_HANDLER)
LOGGING_NULL_HANDLER = None
break
| [
"def",
"__remove_null_logging_handler",
"(",
")",
":",
"global",
"LOGGING_NULL_HANDLER",
"if",
"(",
"LOGGING_NULL_HANDLER",
"is",
"None",
")",
":",
"return",
"root_logger",
"=",
"logging",
".",
"getLogger",
"(",
")",
"for",
"handler",
"in",
"root_logger",
".",
"handlers",
":",
"if",
"(",
"handler",
"is",
"LOGGING_NULL_HANDLER",
")",
":",
"root_logger",
".",
"removeHandler",
"(",
"LOGGING_NULL_HANDLER",
")",
"LOGGING_NULL_HANDLER",
"=",
"None",
"break"
] | this function will run once the temporary logging has been configured . | train | true |
22,603 | def has_potential_command_injection(user_input):
s = shlex.shlex(user_input)
token = s.get_token()
while (token != ''):
if (token in [';', '|', '||', '&', '&&', '>', '>>', '<', '<<', '^', '$', '`', '(', '{']):
print 'Detected potential command injection'
return True
token = s.get_token()
return False
| [
"def",
"has_potential_command_injection",
"(",
"user_input",
")",
":",
"s",
"=",
"shlex",
".",
"shlex",
"(",
"user_input",
")",
"token",
"=",
"s",
".",
"get_token",
"(",
")",
"while",
"(",
"token",
"!=",
"''",
")",
":",
"if",
"(",
"token",
"in",
"[",
"';'",
",",
"'|'",
",",
"'||'",
",",
"'&'",
",",
"'&&'",
",",
"'>'",
",",
"'>>'",
",",
"'<'",
",",
"'<<'",
",",
"'^'",
",",
"'$'",
",",
"'`'",
",",
"'('",
",",
"'{'",
"]",
")",
":",
"print",
"'Detected potential command injection'",
"return",
"True",
"token",
"=",
"s",
".",
"get_token",
"(",
")",
"return",
"False"
] | in order to detect potential command injection methods . | train | false |
22,604 | def umount_volume(mnt_base):
try:
utils.execute('umount.quobyte', mnt_base)
except processutils.ProcessExecutionError as exc:
if ('Device or resource busy' in six.text_type(exc)):
LOG.error(_LE('The Quobyte volume at %s is still in use.'), mnt_base)
else:
LOG.exception(_LE("Couldn't unmount the Quobyte Volume at %s"), mnt_base)
| [
"def",
"umount_volume",
"(",
"mnt_base",
")",
":",
"try",
":",
"utils",
".",
"execute",
"(",
"'umount.quobyte'",
",",
"mnt_base",
")",
"except",
"processutils",
".",
"ProcessExecutionError",
"as",
"exc",
":",
"if",
"(",
"'Device or resource busy'",
"in",
"six",
".",
"text_type",
"(",
"exc",
")",
")",
":",
"LOG",
".",
"error",
"(",
"_LE",
"(",
"'The Quobyte volume at %s is still in use.'",
")",
",",
"mnt_base",
")",
"else",
":",
"LOG",
".",
"exception",
"(",
"_LE",
"(",
"\"Couldn't unmount the Quobyte Volume at %s\"",
")",
",",
"mnt_base",
")"
] | wraps execute calls for unmouting a quobyte volume . | train | false |
22,605 | def fast_could_be_isomorphic(G1, G2):
if (G1.order() != G2.order()):
return False
d1 = G1.degree()
t1 = nx.triangles(G1)
props1 = [[d, t1[v]] for (v, d) in d1]
props1.sort()
d2 = G2.degree()
t2 = nx.triangles(G2)
props2 = [[d, t2[v]] for (v, d) in d2]
props2.sort()
if (props1 != props2):
return False
return True
| [
"def",
"fast_could_be_isomorphic",
"(",
"G1",
",",
"G2",
")",
":",
"if",
"(",
"G1",
".",
"order",
"(",
")",
"!=",
"G2",
".",
"order",
"(",
")",
")",
":",
"return",
"False",
"d1",
"=",
"G1",
".",
"degree",
"(",
")",
"t1",
"=",
"nx",
".",
"triangles",
"(",
"G1",
")",
"props1",
"=",
"[",
"[",
"d",
",",
"t1",
"[",
"v",
"]",
"]",
"for",
"(",
"v",
",",
"d",
")",
"in",
"d1",
"]",
"props1",
".",
"sort",
"(",
")",
"d2",
"=",
"G2",
".",
"degree",
"(",
")",
"t2",
"=",
"nx",
".",
"triangles",
"(",
"G2",
")",
"props2",
"=",
"[",
"[",
"d",
",",
"t2",
"[",
"v",
"]",
"]",
"for",
"(",
"v",
",",
"d",
")",
"in",
"d2",
"]",
"props2",
".",
"sort",
"(",
")",
"if",
"(",
"props1",
"!=",
"props2",
")",
":",
"return",
"False",
"return",
"True"
] | returns false if graphs are definitely not isomorphic . | train | false |
22,606 | def formatUIDListResponse(msgs, getUidl):
(yield successResponse(''))
for ele in formatUIDListLines(msgs, getUidl):
(yield ele)
(yield '.\r\n')
| [
"def",
"formatUIDListResponse",
"(",
"msgs",
",",
"getUidl",
")",
":",
"(",
"yield",
"successResponse",
"(",
"''",
")",
")",
"for",
"ele",
"in",
"formatUIDListLines",
"(",
"msgs",
",",
"getUidl",
")",
":",
"(",
"yield",
"ele",
")",
"(",
"yield",
"'.\\r\\n'",
")"
] | format a list of message sizes appropriately for a complete uidl response . | train | false |
22,607 | def Disconnect(si):
__Logout(si)
SetSi(None)
| [
"def",
"Disconnect",
"(",
"si",
")",
":",
"__Logout",
"(",
"si",
")",
"SetSi",
"(",
"None",
")"
] | disconnect service instance . | train | false |
22,608 | def getFileOrDirectoryTypes(fileName, fileTypes, wasCancelled):
if isEmptyOrCancelled(fileName, wasCancelled):
return []
if isDirectorySetting():
return archive.getFilesWithFileTypesWithoutWords(fileTypes, [], fileName)
return [fileName]
| [
"def",
"getFileOrDirectoryTypes",
"(",
"fileName",
",",
"fileTypes",
",",
"wasCancelled",
")",
":",
"if",
"isEmptyOrCancelled",
"(",
"fileName",
",",
"wasCancelled",
")",
":",
"return",
"[",
"]",
"if",
"isDirectorySetting",
"(",
")",
":",
"return",
"archive",
".",
"getFilesWithFileTypesWithoutWords",
"(",
"fileTypes",
",",
"[",
"]",
",",
"fileName",
")",
"return",
"[",
"fileName",
"]"
] | get the gcode files in the directory the file is in if directory setting is true . | train | false |
22,609 | def parse_dict_querystring(environ):
source = environ.get('QUERY_STRING', '')
if (not source):
return MultiDict()
if ('paste.parsed_dict_querystring' in environ):
(parsed, check_source) = environ['paste.parsed_dict_querystring']
if (check_source == source):
return parsed
parsed = cgi.parse_qsl(source, keep_blank_values=True, strict_parsing=False)
multi = MultiDict(parsed)
environ['paste.parsed_dict_querystring'] = (multi, source)
return multi
| [
"def",
"parse_dict_querystring",
"(",
"environ",
")",
":",
"source",
"=",
"environ",
".",
"get",
"(",
"'QUERY_STRING'",
",",
"''",
")",
"if",
"(",
"not",
"source",
")",
":",
"return",
"MultiDict",
"(",
")",
"if",
"(",
"'paste.parsed_dict_querystring'",
"in",
"environ",
")",
":",
"(",
"parsed",
",",
"check_source",
")",
"=",
"environ",
"[",
"'paste.parsed_dict_querystring'",
"]",
"if",
"(",
"check_source",
"==",
"source",
")",
":",
"return",
"parsed",
"parsed",
"=",
"cgi",
".",
"parse_qsl",
"(",
"source",
",",
"keep_blank_values",
"=",
"True",
",",
"strict_parsing",
"=",
"False",
")",
"multi",
"=",
"MultiDict",
"(",
"parsed",
")",
"environ",
"[",
"'paste.parsed_dict_querystring'",
"]",
"=",
"(",
"multi",
",",
"source",
")",
"return",
"multi"
] | parses a query string like parse_querystring . | train | false |
22,610 | def action_all(options):
lists = get_regexp_lists()
header = [u'#', u'List Name']
table_data = [header]
for regexp_list in lists:
table_data.append([regexp_list.id, regexp_list.name])
table = TerminalTable(options.table_type, table_data)
try:
console(table.output)
except TerminalTableError as e:
console((u'ERROR: %s' % str(e)))
| [
"def",
"action_all",
"(",
"options",
")",
":",
"lists",
"=",
"get_regexp_lists",
"(",
")",
"header",
"=",
"[",
"u'#'",
",",
"u'List Name'",
"]",
"table_data",
"=",
"[",
"header",
"]",
"for",
"regexp_list",
"in",
"lists",
":",
"table_data",
".",
"append",
"(",
"[",
"regexp_list",
".",
"id",
",",
"regexp_list",
".",
"name",
"]",
")",
"table",
"=",
"TerminalTable",
"(",
"options",
".",
"table_type",
",",
"table_data",
")",
"try",
":",
"console",
"(",
"table",
".",
"output",
")",
"except",
"TerminalTableError",
"as",
"e",
":",
"console",
"(",
"(",
"u'ERROR: %s'",
"%",
"str",
"(",
"e",
")",
")",
")"
] | show all regexp lists . | train | false |
22,611 | def _sort_map_entries(category_map, sort_alpha):
things = []
for (title, entry) in category_map['entries'].items():
if ((entry['sort_key'] is None) and sort_alpha):
entry['sort_key'] = title
things.append((title, entry, TYPE_ENTRY))
for (title, category) in category_map['subcategories'].items():
things.append((title, category, TYPE_SUBCATEGORY))
_sort_map_entries(category_map['subcategories'][title], sort_alpha)
category_map['children'] = [(x[0], x[2]) for x in sorted(things, key=(lambda x: x[1]['sort_key']))]
| [
"def",
"_sort_map_entries",
"(",
"category_map",
",",
"sort_alpha",
")",
":",
"things",
"=",
"[",
"]",
"for",
"(",
"title",
",",
"entry",
")",
"in",
"category_map",
"[",
"'entries'",
"]",
".",
"items",
"(",
")",
":",
"if",
"(",
"(",
"entry",
"[",
"'sort_key'",
"]",
"is",
"None",
")",
"and",
"sort_alpha",
")",
":",
"entry",
"[",
"'sort_key'",
"]",
"=",
"title",
"things",
".",
"append",
"(",
"(",
"title",
",",
"entry",
",",
"TYPE_ENTRY",
")",
")",
"for",
"(",
"title",
",",
"category",
")",
"in",
"category_map",
"[",
"'subcategories'",
"]",
".",
"items",
"(",
")",
":",
"things",
".",
"append",
"(",
"(",
"title",
",",
"category",
",",
"TYPE_SUBCATEGORY",
")",
")",
"_sort_map_entries",
"(",
"category_map",
"[",
"'subcategories'",
"]",
"[",
"title",
"]",
",",
"sort_alpha",
")",
"category_map",
"[",
"'children'",
"]",
"=",
"[",
"(",
"x",
"[",
"0",
"]",
",",
"x",
"[",
"2",
"]",
")",
"for",
"x",
"in",
"sorted",
"(",
"things",
",",
"key",
"=",
"(",
"lambda",
"x",
":",
"x",
"[",
"1",
"]",
"[",
"'sort_key'",
"]",
")",
")",
"]"
] | internal helper method to list category entries according to the provided sort order . | train | false |
22,612 | def corner(sankey):
prior = len(sankey.diagrams)
sankey.add(flows=[1, (-1)], orientations=[0, 1], patchlabel=str(prior), facecolor='k', prior=(prior - 1), connect=(1, 0), alpha=0.5)
| [
"def",
"corner",
"(",
"sankey",
")",
":",
"prior",
"=",
"len",
"(",
"sankey",
".",
"diagrams",
")",
"sankey",
".",
"add",
"(",
"flows",
"=",
"[",
"1",
",",
"(",
"-",
"1",
")",
"]",
",",
"orientations",
"=",
"[",
"0",
",",
"1",
"]",
",",
"patchlabel",
"=",
"str",
"(",
"prior",
")",
",",
"facecolor",
"=",
"'k'",
",",
"prior",
"=",
"(",
"prior",
"-",
"1",
")",
",",
"connect",
"=",
"(",
"1",
",",
"0",
")",
",",
"alpha",
"=",
"0.5",
")"
] | generate a corner link . | train | false |
22,613 | def _prefix_number_with_country_calling_code(country_code, num_format, formatted_number):
if (num_format == PhoneNumberFormat.E164):
return ((_PLUS_SIGN + unicod(country_code)) + formatted_number)
elif (num_format == PhoneNumberFormat.INTERNATIONAL):
return (((_PLUS_SIGN + unicod(country_code)) + U_SPACE) + formatted_number)
elif (num_format == PhoneNumberFormat.RFC3966):
return ((((_RFC3966_PREFIX + _PLUS_SIGN) + unicod(country_code)) + U_DASH) + formatted_number)
else:
return formatted_number
| [
"def",
"_prefix_number_with_country_calling_code",
"(",
"country_code",
",",
"num_format",
",",
"formatted_number",
")",
":",
"if",
"(",
"num_format",
"==",
"PhoneNumberFormat",
".",
"E164",
")",
":",
"return",
"(",
"(",
"_PLUS_SIGN",
"+",
"unicod",
"(",
"country_code",
")",
")",
"+",
"formatted_number",
")",
"elif",
"(",
"num_format",
"==",
"PhoneNumberFormat",
".",
"INTERNATIONAL",
")",
":",
"return",
"(",
"(",
"(",
"_PLUS_SIGN",
"+",
"unicod",
"(",
"country_code",
")",
")",
"+",
"U_SPACE",
")",
"+",
"formatted_number",
")",
"elif",
"(",
"num_format",
"==",
"PhoneNumberFormat",
".",
"RFC3966",
")",
":",
"return",
"(",
"(",
"(",
"(",
"_RFC3966_PREFIX",
"+",
"_PLUS_SIGN",
")",
"+",
"unicod",
"(",
"country_code",
")",
")",
"+",
"U_DASH",
")",
"+",
"formatted_number",
")",
"else",
":",
"return",
"formatted_number"
] | a helper function that is used by format_number and format_by_pattern . | train | true |
22,615 | def dist_to_mat(cord, vec, matidxlist, mcmap, invert=False, limit=False):
assert isinstance(mcmap, mcInterface.SaveFile)
block = mcmap.block
curcord = [(i + 0.5) for i in cord]
iterations = 0
on_map = True
while on_map:
x = int(curcord[0])
y = int(curcord[1])
z = int(curcord[2])
return_dict = block(x, y, z)
if (return_dict is None):
break
else:
block_value = return_dict['B']
if ((block_value in matidxlist) and (invert == False)):
break
elif ((block_value not in matidxlist) and invert):
break
else:
curcord = [(curcord[i] + vec[i]) for i in range(3)]
iterations += 1
if (limit and (iterations > limit)):
break
return iterations
| [
"def",
"dist_to_mat",
"(",
"cord",
",",
"vec",
",",
"matidxlist",
",",
"mcmap",
",",
"invert",
"=",
"False",
",",
"limit",
"=",
"False",
")",
":",
"assert",
"isinstance",
"(",
"mcmap",
",",
"mcInterface",
".",
"SaveFile",
")",
"block",
"=",
"mcmap",
".",
"block",
"curcord",
"=",
"[",
"(",
"i",
"+",
"0.5",
")",
"for",
"i",
"in",
"cord",
"]",
"iterations",
"=",
"0",
"on_map",
"=",
"True",
"while",
"on_map",
":",
"x",
"=",
"int",
"(",
"curcord",
"[",
"0",
"]",
")",
"y",
"=",
"int",
"(",
"curcord",
"[",
"1",
"]",
")",
"z",
"=",
"int",
"(",
"curcord",
"[",
"2",
"]",
")",
"return_dict",
"=",
"block",
"(",
"x",
",",
"y",
",",
"z",
")",
"if",
"(",
"return_dict",
"is",
"None",
")",
":",
"break",
"else",
":",
"block_value",
"=",
"return_dict",
"[",
"'B'",
"]",
"if",
"(",
"(",
"block_value",
"in",
"matidxlist",
")",
"and",
"(",
"invert",
"==",
"False",
")",
")",
":",
"break",
"elif",
"(",
"(",
"block_value",
"not",
"in",
"matidxlist",
")",
"and",
"invert",
")",
":",
"break",
"else",
":",
"curcord",
"=",
"[",
"(",
"curcord",
"[",
"i",
"]",
"+",
"vec",
"[",
"i",
"]",
")",
"for",
"i",
"in",
"range",
"(",
"3",
")",
"]",
"iterations",
"+=",
"1",
"if",
"(",
"limit",
"and",
"(",
"iterations",
">",
"limit",
")",
")",
":",
"break",
"return",
"iterations"
] | travel from cord along vec and return how far it was to a point of matidx the distance is returned in number of iterations . | train | false |
22,618 | def _serializer(obj):
import datetime
if isinstance(obj, datetime.datetime):
if (obj.utcoffset() is not None):
obj = (obj - obj.utcoffset())
return obj.__str__()
return obj
| [
"def",
"_serializer",
"(",
"obj",
")",
":",
"import",
"datetime",
"if",
"isinstance",
"(",
"obj",
",",
"datetime",
".",
"datetime",
")",
":",
"if",
"(",
"obj",
".",
"utcoffset",
"(",
")",
"is",
"not",
"None",
")",
":",
"obj",
"=",
"(",
"obj",
"-",
"obj",
".",
"utcoffset",
"(",
")",
")",
"return",
"obj",
".",
"__str__",
"(",
")",
"return",
"obj"
] | helper function to serialize some objects for prettier return . | train | true |
22,621 | def colored(text, color=None, on_color=None, attrs=None):
if (os.getenv('ANSI_COLORS_DISABLED') is None):
fmt_str = '\x1b[%dm%s'
if (color is not None):
text = (fmt_str % (COLORS[color], text))
if (on_color is not None):
text = (fmt_str % (HIGHLIGHTS[on_color], text))
if (attrs is not None):
for attr in attrs:
text = (fmt_str % (ATTRIBUTES[attr], text))
text += RESET
return text
| [
"def",
"colored",
"(",
"text",
",",
"color",
"=",
"None",
",",
"on_color",
"=",
"None",
",",
"attrs",
"=",
"None",
")",
":",
"if",
"(",
"os",
".",
"getenv",
"(",
"'ANSI_COLORS_DISABLED'",
")",
"is",
"None",
")",
":",
"fmt_str",
"=",
"'\\x1b[%dm%s'",
"if",
"(",
"color",
"is",
"not",
"None",
")",
":",
"text",
"=",
"(",
"fmt_str",
"%",
"(",
"COLORS",
"[",
"color",
"]",
",",
"text",
")",
")",
"if",
"(",
"on_color",
"is",
"not",
"None",
")",
":",
"text",
"=",
"(",
"fmt_str",
"%",
"(",
"HIGHLIGHTS",
"[",
"on_color",
"]",
",",
"text",
")",
")",
"if",
"(",
"attrs",
"is",
"not",
"None",
")",
":",
"for",
"attr",
"in",
"attrs",
":",
"text",
"=",
"(",
"fmt_str",
"%",
"(",
"ATTRIBUTES",
"[",
"attr",
"]",
",",
"text",
")",
")",
"text",
"+=",
"RESET",
"return",
"text"
] | colorize text . | train | true |
22,622 | def _convertTime(title, fromPTDFtoWEB=1, _emptyString=u''):
try:
if fromPTDFtoWEB:
from_format = _ptdf_format
to_format = _web_format
else:
from_format = (u'Episode dated %s' % _web_format)
to_format = _ptdf_format
t = strptime(title, from_format)
title = strftime(to_format, t)
if fromPTDFtoWEB:
if (title[0] == '0'):
title = title[1:]
title = (u'Episode dated %s' % title)
except ValueError:
pass
if isinstance(_emptyString, str):
try:
title = str(title)
except UnicodeDecodeError:
pass
return title
| [
"def",
"_convertTime",
"(",
"title",
",",
"fromPTDFtoWEB",
"=",
"1",
",",
"_emptyString",
"=",
"u''",
")",
":",
"try",
":",
"if",
"fromPTDFtoWEB",
":",
"from_format",
"=",
"_ptdf_format",
"to_format",
"=",
"_web_format",
"else",
":",
"from_format",
"=",
"(",
"u'Episode dated %s'",
"%",
"_web_format",
")",
"to_format",
"=",
"_ptdf_format",
"t",
"=",
"strptime",
"(",
"title",
",",
"from_format",
")",
"title",
"=",
"strftime",
"(",
"to_format",
",",
"t",
")",
"if",
"fromPTDFtoWEB",
":",
"if",
"(",
"title",
"[",
"0",
"]",
"==",
"'0'",
")",
":",
"title",
"=",
"title",
"[",
"1",
":",
"]",
"title",
"=",
"(",
"u'Episode dated %s'",
"%",
"title",
")",
"except",
"ValueError",
":",
"pass",
"if",
"isinstance",
"(",
"_emptyString",
",",
"str",
")",
":",
"try",
":",
"title",
"=",
"str",
"(",
"title",
")",
"except",
"UnicodeDecodeError",
":",
"pass",
"return",
"title"
] | convert a time expressed in the pain text data files . | train | false |
22,623 | def _testPermissions(uid, gid, spath, mode='r'):
if (mode == 'r'):
usr = stat.S_IRUSR
grp = stat.S_IRGRP
oth = stat.S_IROTH
amode = os.R_OK
elif (mode == 'w'):
usr = stat.S_IWUSR
grp = stat.S_IWGRP
oth = stat.S_IWOTH
amode = os.W_OK
else:
raise ValueError(("Invalid mode %r: must specify 'r' or 'w'" % (mode,)))
access = False
if os.path.exists(spath):
if (uid == 0):
access = True
else:
s = os.stat(spath)
if ((usr & s.st_mode) and (uid == s.st_uid)):
access = True
elif ((grp & s.st_mode) and (gid in _getgroups(uid))):
access = True
elif (oth & s.st_mode):
access = True
if access:
if (not os.access(spath, amode)):
access = False
log.msg(('Filesystem grants permission to UID %d but it is inaccessible to me running as UID %d' % (uid, os.getuid())))
return access
| [
"def",
"_testPermissions",
"(",
"uid",
",",
"gid",
",",
"spath",
",",
"mode",
"=",
"'r'",
")",
":",
"if",
"(",
"mode",
"==",
"'r'",
")",
":",
"usr",
"=",
"stat",
".",
"S_IRUSR",
"grp",
"=",
"stat",
".",
"S_IRGRP",
"oth",
"=",
"stat",
".",
"S_IROTH",
"amode",
"=",
"os",
".",
"R_OK",
"elif",
"(",
"mode",
"==",
"'w'",
")",
":",
"usr",
"=",
"stat",
".",
"S_IWUSR",
"grp",
"=",
"stat",
".",
"S_IWGRP",
"oth",
"=",
"stat",
".",
"S_IWOTH",
"amode",
"=",
"os",
".",
"W_OK",
"else",
":",
"raise",
"ValueError",
"(",
"(",
"\"Invalid mode %r: must specify 'r' or 'w'\"",
"%",
"(",
"mode",
",",
")",
")",
")",
"access",
"=",
"False",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"spath",
")",
":",
"if",
"(",
"uid",
"==",
"0",
")",
":",
"access",
"=",
"True",
"else",
":",
"s",
"=",
"os",
".",
"stat",
"(",
"spath",
")",
"if",
"(",
"(",
"usr",
"&",
"s",
".",
"st_mode",
")",
"and",
"(",
"uid",
"==",
"s",
".",
"st_uid",
")",
")",
":",
"access",
"=",
"True",
"elif",
"(",
"(",
"grp",
"&",
"s",
".",
"st_mode",
")",
"and",
"(",
"gid",
"in",
"_getgroups",
"(",
"uid",
")",
")",
")",
":",
"access",
"=",
"True",
"elif",
"(",
"oth",
"&",
"s",
".",
"st_mode",
")",
":",
"access",
"=",
"True",
"if",
"access",
":",
"if",
"(",
"not",
"os",
".",
"access",
"(",
"spath",
",",
"amode",
")",
")",
":",
"access",
"=",
"False",
"log",
".",
"msg",
"(",
"(",
"'Filesystem grants permission to UID %d but it is inaccessible to me running as UID %d'",
"%",
"(",
"uid",
",",
"os",
".",
"getuid",
"(",
")",
")",
")",
")",
"return",
"access"
] | checks to see if uid has proper permissions to access path with mode @type uid: c{int} . | train | false |
22,625 | def callLater_weakly(delay, func, *args, **kwargs):
warnings.warn('deprecated', DeprecationWarning)
def cleanup(weakmeth, thedeadweakref):
if weakmeth.callId.active():
weakmeth.callId.cancel()
weakmeth = WeakMethod(func, callback=cleanup)
weakmeth.callId = reactor.callLater(delay, weakmeth, *args, **kwargs)
return weakmeth
| [
"def",
"callLater_weakly",
"(",
"delay",
",",
"func",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"warnings",
".",
"warn",
"(",
"'deprecated'",
",",
"DeprecationWarning",
")",
"def",
"cleanup",
"(",
"weakmeth",
",",
"thedeadweakref",
")",
":",
"if",
"weakmeth",
".",
"callId",
".",
"active",
"(",
")",
":",
"weakmeth",
".",
"callId",
".",
"cancel",
"(",
")",
"weakmeth",
"=",
"WeakMethod",
"(",
"func",
",",
"callback",
"=",
"cleanup",
")",
"weakmeth",
".",
"callId",
"=",
"reactor",
".",
"callLater",
"(",
"delay",
",",
"weakmeth",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
"return",
"weakmeth"
] | call func later . | train | false |
22,626 | def is_solenoidal(field):
if (not isinstance(field, Vector)):
raise TypeError('field should be a Vector')
if (field == Vector.zero):
return True
coord_sys = list(field.separate())[0]
return (divergence(field, coord_sys).simplify() == S(0))
| [
"def",
"is_solenoidal",
"(",
"field",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"field",
",",
"Vector",
")",
")",
":",
"raise",
"TypeError",
"(",
"'field should be a Vector'",
")",
"if",
"(",
"field",
"==",
"Vector",
".",
"zero",
")",
":",
"return",
"True",
"coord_sys",
"=",
"list",
"(",
"field",
".",
"separate",
"(",
")",
")",
"[",
"0",
"]",
"return",
"(",
"divergence",
"(",
"field",
",",
"coord_sys",
")",
".",
"simplify",
"(",
")",
"==",
"S",
"(",
"0",
")",
")"
] | checks if a field is solenoidal . | train | false |
22,627 | def serializable(arg=None, **kwargs):
if isinstance(arg, FunctionType):
decorator = True
func = arg
serialized_type = BaseType
elif ((arg is None) or isinstance(arg, (BaseType, TypeMeta))):
decorator = False
serialized_type = (arg or kwargs.pop(u'type', BaseType))
else:
raise TypeError(u"The argument to 'serializable' must be a function or a type.")
if isinstance(serialized_type, BaseType):
serialized_type._set_export_level(kwargs.pop(u'export_level', None), kwargs.pop(u'serialize_when_none', None))
for (name, value) in kwargs.items():
setattr(serialized_type, name, value)
else:
serialized_type = serialized_type(**kwargs)
if decorator:
return Serializable(func, serialized_type)
else:
return partial(Serializable, type=serialized_type)
| [
"def",
"serializable",
"(",
"arg",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"arg",
",",
"FunctionType",
")",
":",
"decorator",
"=",
"True",
"func",
"=",
"arg",
"serialized_type",
"=",
"BaseType",
"elif",
"(",
"(",
"arg",
"is",
"None",
")",
"or",
"isinstance",
"(",
"arg",
",",
"(",
"BaseType",
",",
"TypeMeta",
")",
")",
")",
":",
"decorator",
"=",
"False",
"serialized_type",
"=",
"(",
"arg",
"or",
"kwargs",
".",
"pop",
"(",
"u'type'",
",",
"BaseType",
")",
")",
"else",
":",
"raise",
"TypeError",
"(",
"u\"The argument to 'serializable' must be a function or a type.\"",
")",
"if",
"isinstance",
"(",
"serialized_type",
",",
"BaseType",
")",
":",
"serialized_type",
".",
"_set_export_level",
"(",
"kwargs",
".",
"pop",
"(",
"u'export_level'",
",",
"None",
")",
",",
"kwargs",
".",
"pop",
"(",
"u'serialize_when_none'",
",",
"None",
")",
")",
"for",
"(",
"name",
",",
"value",
")",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"setattr",
"(",
"serialized_type",
",",
"name",
",",
"value",
")",
"else",
":",
"serialized_type",
"=",
"serialized_type",
"(",
"**",
"kwargs",
")",
"if",
"decorator",
":",
"return",
"Serializable",
"(",
"func",
",",
"serialized_type",
")",
"else",
":",
"return",
"partial",
"(",
"Serializable",
",",
"type",
"=",
"serialized_type",
")"
] | a serializable is a way to define dynamic serializable fields that are derived from other fields . | train | false |
22,628 | def greet(greetee):
return green((u'Hello, %s!' % greetee))
| [
"def",
"greet",
"(",
"greetee",
")",
":",
"return",
"green",
"(",
"(",
"u'Hello, %s!'",
"%",
"greetee",
")",
")"
] | logs a friendly greeting to person given as argument . | train | false |
22,629 | def cronite_datetime_to_timestamp(self, d):
if (d.tzinfo is not None):
d = (d.replace(tzinfo=None) - d.utcoffset())
return total_seconds((d - datetime.datetime(1970, 1, 1)))
| [
"def",
"cronite_datetime_to_timestamp",
"(",
"self",
",",
"d",
")",
":",
"if",
"(",
"d",
".",
"tzinfo",
"is",
"not",
"None",
")",
":",
"d",
"=",
"(",
"d",
".",
"replace",
"(",
"tzinfo",
"=",
"None",
")",
"-",
"d",
".",
"utcoffset",
"(",
")",
")",
"return",
"total_seconds",
"(",
"(",
"d",
"-",
"datetime",
".",
"datetime",
"(",
"1970",
",",
"1",
",",
"1",
")",
")",
")"
] | converts a datetime object d into a unix timestamp . | train | false |
22,632 | def parse_machine(machine, user='root', password='', port=22, profile=''):
if ('@' in machine):
(user, machine) = machine.split('@', 1)
if (':' in user):
(user, password) = user.split(':', 1)
if (':' in machine):
(machine, port) = machine.split(':', 1)
try:
port = int(port)
except ValueError:
(port, profile) = port.split('#', 1)
port = int(port)
if ('#' in machine):
(machine, profile) = machine.split('#', 1)
if ((not machine) or (not user)):
raise ValueError
return (machine, user, password, port, profile)
| [
"def",
"parse_machine",
"(",
"machine",
",",
"user",
"=",
"'root'",
",",
"password",
"=",
"''",
",",
"port",
"=",
"22",
",",
"profile",
"=",
"''",
")",
":",
"if",
"(",
"'@'",
"in",
"machine",
")",
":",
"(",
"user",
",",
"machine",
")",
"=",
"machine",
".",
"split",
"(",
"'@'",
",",
"1",
")",
"if",
"(",
"':'",
"in",
"user",
")",
":",
"(",
"user",
",",
"password",
")",
"=",
"user",
".",
"split",
"(",
"':'",
",",
"1",
")",
"if",
"(",
"':'",
"in",
"machine",
")",
":",
"(",
"machine",
",",
"port",
")",
"=",
"machine",
".",
"split",
"(",
"':'",
",",
"1",
")",
"try",
":",
"port",
"=",
"int",
"(",
"port",
")",
"except",
"ValueError",
":",
"(",
"port",
",",
"profile",
")",
"=",
"port",
".",
"split",
"(",
"'#'",
",",
"1",
")",
"port",
"=",
"int",
"(",
"port",
")",
"if",
"(",
"'#'",
"in",
"machine",
")",
":",
"(",
"machine",
",",
"profile",
")",
"=",
"machine",
".",
"split",
"(",
"'#'",
",",
"1",
")",
"if",
"(",
"(",
"not",
"machine",
")",
"or",
"(",
"not",
"user",
")",
")",
":",
"raise",
"ValueError",
"return",
"(",
"machine",
",",
"user",
",",
"password",
",",
"port",
",",
"profile",
")"
] | parse the machine string user:pass@host#profile:port and return it separately . | train | false |
22,633 | def rebuild_all_dbs(Session):
db_read_url_parts = cli.parse_db_config('ckan.datastore.write_url')
db_ckan_url_parts = cli.parse_db_config('sqlalchemy.url')
same_db = (db_read_url_parts['db_name'] == db_ckan_url_parts['db_name'])
if same_db:
model.repo.tables_created_and_initialised = False
clear_db(Session)
model.repo.rebuild_db()
| [
"def",
"rebuild_all_dbs",
"(",
"Session",
")",
":",
"db_read_url_parts",
"=",
"cli",
".",
"parse_db_config",
"(",
"'ckan.datastore.write_url'",
")",
"db_ckan_url_parts",
"=",
"cli",
".",
"parse_db_config",
"(",
"'sqlalchemy.url'",
")",
"same_db",
"=",
"(",
"db_read_url_parts",
"[",
"'db_name'",
"]",
"==",
"db_ckan_url_parts",
"[",
"'db_name'",
"]",
")",
"if",
"same_db",
":",
"model",
".",
"repo",
".",
"tables_created_and_initialised",
"=",
"False",
"clear_db",
"(",
"Session",
")",
"model",
".",
"repo",
".",
"rebuild_db",
"(",
")"
] | if the tests are running on the same db . | train | false |
22,634 | def convert_cidr(cidr):
ret = {'network': None, 'netmask': None}
cidr = calc_net(cidr)
network_info = salt.ext.ipaddress.ip_network(cidr)
ret['network'] = str(network_info.network_address)
ret['netmask'] = str(network_info.netmask)
return ret
| [
"def",
"convert_cidr",
"(",
"cidr",
")",
":",
"ret",
"=",
"{",
"'network'",
":",
"None",
",",
"'netmask'",
":",
"None",
"}",
"cidr",
"=",
"calc_net",
"(",
"cidr",
")",
"network_info",
"=",
"salt",
".",
"ext",
".",
"ipaddress",
".",
"ip_network",
"(",
"cidr",
")",
"ret",
"[",
"'network'",
"]",
"=",
"str",
"(",
"network_info",
".",
"network_address",
")",
"ret",
"[",
"'netmask'",
"]",
"=",
"str",
"(",
"network_info",
".",
"netmask",
")",
"return",
"ret"
] | returns the network and subnet mask of a cidr addr . | train | false |
22,636 | def run_commentstree(qname='commentstree_q', limit=400):
@g.stats.amqp_processor(qname)
def _run_commentstree(msgs, chan):
comments = Comment._by_fullname([msg.body for msg in msgs], data=True, return_dict=False)
print ('Processing %r' % (comments,))
if comments:
add_comments(comments)
if (qname == 'commentstree_fastlane_q'):
limit = max(1000, limit)
amqp.handle_items(qname, _run_commentstree, limit=limit)
| [
"def",
"run_commentstree",
"(",
"qname",
"=",
"'commentstree_q'",
",",
"limit",
"=",
"400",
")",
":",
"@",
"g",
".",
"stats",
".",
"amqp_processor",
"(",
"qname",
")",
"def",
"_run_commentstree",
"(",
"msgs",
",",
"chan",
")",
":",
"comments",
"=",
"Comment",
".",
"_by_fullname",
"(",
"[",
"msg",
".",
"body",
"for",
"msg",
"in",
"msgs",
"]",
",",
"data",
"=",
"True",
",",
"return_dict",
"=",
"False",
")",
"print",
"(",
"'Processing %r'",
"%",
"(",
"comments",
",",
")",
")",
"if",
"comments",
":",
"add_comments",
"(",
"comments",
")",
"if",
"(",
"qname",
"==",
"'commentstree_fastlane_q'",
")",
":",
"limit",
"=",
"max",
"(",
"1000",
",",
"limit",
")",
"amqp",
".",
"handle_items",
"(",
"qname",
",",
"_run_commentstree",
",",
"limit",
"=",
"limit",
")"
] | add new incoming comments to their respective comments trees . | train | false |
22,637 | def fragcascade(attr, seq_type, doc=''):
assert (seq_type in ('hit', 'query'))
attr_name = ('_%s_%s' % (seq_type, attr))
def getter(self):
return getattr(self, attr_name)
def setter(self, value):
setattr(self, attr_name, value)
seq = getattr(self, seq_type)
if (seq is not None):
setattr(seq, attr, value)
return property(fget=getter, fset=setter, doc=doc)
| [
"def",
"fragcascade",
"(",
"attr",
",",
"seq_type",
",",
"doc",
"=",
"''",
")",
":",
"assert",
"(",
"seq_type",
"in",
"(",
"'hit'",
",",
"'query'",
")",
")",
"attr_name",
"=",
"(",
"'_%s_%s'",
"%",
"(",
"seq_type",
",",
"attr",
")",
")",
"def",
"getter",
"(",
"self",
")",
":",
"return",
"getattr",
"(",
"self",
",",
"attr_name",
")",
"def",
"setter",
"(",
"self",
",",
"value",
")",
":",
"setattr",
"(",
"self",
",",
"attr_name",
",",
"value",
")",
"seq",
"=",
"getattr",
"(",
"self",
",",
"seq_type",
")",
"if",
"(",
"seq",
"is",
"not",
"None",
")",
":",
"setattr",
"(",
"seq",
",",
"attr",
",",
"value",
")",
"return",
"property",
"(",
"fget",
"=",
"getter",
",",
"fset",
"=",
"setter",
",",
"doc",
"=",
"doc",
")"
] | returns a getter property with cascading setter . | train | false |
22,639 | def createCertificate(req, issuerCertKey, serial, validityPeriod, digest='sha256'):
(issuerCert, issuerKey) = issuerCertKey
(notBefore, notAfter) = validityPeriod
cert = crypto.X509()
cert.set_serial_number(serial)
cert.gmtime_adj_notBefore(notBefore)
cert.gmtime_adj_notAfter(notAfter)
cert.set_issuer(issuerCert.get_subject())
cert.set_subject(req.get_subject())
cert.set_pubkey(req.get_pubkey())
cert.sign(issuerKey, digest)
return cert
| [
"def",
"createCertificate",
"(",
"req",
",",
"issuerCertKey",
",",
"serial",
",",
"validityPeriod",
",",
"digest",
"=",
"'sha256'",
")",
":",
"(",
"issuerCert",
",",
"issuerKey",
")",
"=",
"issuerCertKey",
"(",
"notBefore",
",",
"notAfter",
")",
"=",
"validityPeriod",
"cert",
"=",
"crypto",
".",
"X509",
"(",
")",
"cert",
".",
"set_serial_number",
"(",
"serial",
")",
"cert",
".",
"gmtime_adj_notBefore",
"(",
"notBefore",
")",
"cert",
".",
"gmtime_adj_notAfter",
"(",
"notAfter",
")",
"cert",
".",
"set_issuer",
"(",
"issuerCert",
".",
"get_subject",
"(",
")",
")",
"cert",
".",
"set_subject",
"(",
"req",
".",
"get_subject",
"(",
")",
")",
"cert",
".",
"set_pubkey",
"(",
"req",
".",
"get_pubkey",
"(",
")",
")",
"cert",
".",
"sign",
"(",
"issuerKey",
",",
"digest",
")",
"return",
"cert"
] | generate a certificate given a certificate request . | train | true |
22,640 | def populate():
print
print 'Creating roles...'
create_roles()
print 'Creating services...'
create_services()
print 'Creating permissions...'
create_permissions()
print 'Creating custom system roles...'
create_custom_sys_roles()
print 'Creating admin panel permissions...'
create_panel_permissions()
print 'Creating user permissions...'
create_user_permissions()
print 'Creating admin message settings...'
create_admin_message_settings()
db.session.commit()
| [
"def",
"populate",
"(",
")",
":",
"print",
"print",
"'Creating roles...'",
"create_roles",
"(",
")",
"print",
"'Creating services...'",
"create_services",
"(",
")",
"print",
"'Creating permissions...'",
"create_permissions",
"(",
")",
"print",
"'Creating custom system roles...'",
"create_custom_sys_roles",
"(",
")",
"print",
"'Creating admin panel permissions...'",
"create_panel_permissions",
"(",
")",
"print",
"'Creating user permissions...'",
"create_user_permissions",
"(",
")",
"print",
"'Creating admin message settings...'",
"create_admin_message_settings",
"(",
")",
"db",
".",
"session",
".",
"commit",
"(",
")"
] | populate table with n records . | train | false |
22,641 | @remote_data
def test_invalid_location_download():
from ..data import download_file
with pytest.raises(urllib.error.URLError):
download_file(u'http://astropy.org/nonexistentfile')
| [
"@",
"remote_data",
"def",
"test_invalid_location_download",
"(",
")",
":",
"from",
".",
".",
"data",
"import",
"download_file",
"with",
"pytest",
".",
"raises",
"(",
"urllib",
".",
"error",
".",
"URLError",
")",
":",
"download_file",
"(",
"u'http://astropy.org/nonexistentfile'",
")"
] | checks that download_file gives a urlerror and not an attributeerror . | train | false |
22,642 | def _find_bad_optimizations2(order, reasons, r_vals):
checked_variables = set()
def check_variable_norec(new_r):
'\n Verify that `r` has the same value as the results it replaces.\n\n '
for (reason, r, old_graph_str, new_graph_str) in reasons[new_r]:
new_r_val = r_vals[new_r]
r_val = r_vals[r]
if ((r.type != new_r.type) or (not r.type.values_eq_approx(r_val, new_r_val))):
raise BadOptimization(old_r=r, new_r=new_r, old_r_val=r_val, new_r_val=new_r_val, reason=reason, old_graph=old_graph_str, new_graph=new_graph_str)
def check_variable(r):
if (r in checked_variables):
return
checked_variables.add(r)
list_of_vars = [old_r for (reason, old_r, olds, news) in reasons[r]]
if (None is not r.owner):
list_of_vars += r.owner.inputs
for var_that_could_make_r_look_bad in list_of_vars:
check_variable(var_that_could_make_r_look_bad)
check_variable_norec(r)
for (i, node) in enumerate(order):
for new_r in node.outputs:
check_variable(new_r)
| [
"def",
"_find_bad_optimizations2",
"(",
"order",
",",
"reasons",
",",
"r_vals",
")",
":",
"checked_variables",
"=",
"set",
"(",
")",
"def",
"check_variable_norec",
"(",
"new_r",
")",
":",
"for",
"(",
"reason",
",",
"r",
",",
"old_graph_str",
",",
"new_graph_str",
")",
"in",
"reasons",
"[",
"new_r",
"]",
":",
"new_r_val",
"=",
"r_vals",
"[",
"new_r",
"]",
"r_val",
"=",
"r_vals",
"[",
"r",
"]",
"if",
"(",
"(",
"r",
".",
"type",
"!=",
"new_r",
".",
"type",
")",
"or",
"(",
"not",
"r",
".",
"type",
".",
"values_eq_approx",
"(",
"r_val",
",",
"new_r_val",
")",
")",
")",
":",
"raise",
"BadOptimization",
"(",
"old_r",
"=",
"r",
",",
"new_r",
"=",
"new_r",
",",
"old_r_val",
"=",
"r_val",
",",
"new_r_val",
"=",
"new_r_val",
",",
"reason",
"=",
"reason",
",",
"old_graph",
"=",
"old_graph_str",
",",
"new_graph",
"=",
"new_graph_str",
")",
"def",
"check_variable",
"(",
"r",
")",
":",
"if",
"(",
"r",
"in",
"checked_variables",
")",
":",
"return",
"checked_variables",
".",
"add",
"(",
"r",
")",
"list_of_vars",
"=",
"[",
"old_r",
"for",
"(",
"reason",
",",
"old_r",
",",
"olds",
",",
"news",
")",
"in",
"reasons",
"[",
"r",
"]",
"]",
"if",
"(",
"None",
"is",
"not",
"r",
".",
"owner",
")",
":",
"list_of_vars",
"+=",
"r",
".",
"owner",
".",
"inputs",
"for",
"var_that_could_make_r_look_bad",
"in",
"list_of_vars",
":",
"check_variable",
"(",
"var_that_could_make_r_look_bad",
")",
"check_variable_norec",
"(",
"r",
")",
"for",
"(",
"i",
",",
"node",
")",
"in",
"enumerate",
"(",
"order",
")",
":",
"for",
"new_r",
"in",
"node",
".",
"outputs",
":",
"check_variable",
"(",
"new_r",
")"
] | use a simple algorithm to find broken optimizations . | train | false |
22,643 | def read_plain_byte_array_fixed(file_obj, fixed_length):
return file_obj.read(fixed_length)
| [
"def",
"read_plain_byte_array_fixed",
"(",
"file_obj",
",",
"fixed_length",
")",
":",
"return",
"file_obj",
".",
"read",
"(",
"fixed_length",
")"
] | read a byte array of the given fixed_length . | train | false |
22,646 | def is_attr_protected(attrname):
return ((attrname[0] == '_') and (not (attrname == '_')) and (not (attrname.startswith('__') and attrname.endswith('__'))))
| [
"def",
"is_attr_protected",
"(",
"attrname",
")",
":",
"return",
"(",
"(",
"attrname",
"[",
"0",
"]",
"==",
"'_'",
")",
"and",
"(",
"not",
"(",
"attrname",
"==",
"'_'",
")",
")",
"and",
"(",
"not",
"(",
"attrname",
".",
"startswith",
"(",
"'__'",
")",
"and",
"attrname",
".",
"endswith",
"(",
"'__'",
")",
")",
")",
")"
] | return true if attribute name is protected . | train | false |
22,647 | def quiet_shutdown(socket_instance):
try:
socket_instance.shutdown(socket.SHUT_RDWR)
except Exception:
logger.debug(u'Exception while shutting down a socket', exc_info=True)
| [
"def",
"quiet_shutdown",
"(",
"socket_instance",
")",
":",
"try",
":",
"socket_instance",
".",
"shutdown",
"(",
"socket",
".",
"SHUT_RDWR",
")",
"except",
"Exception",
":",
"logger",
".",
"debug",
"(",
"u'Exception while shutting down a socket'",
",",
"exc_info",
"=",
"True",
")"
] | quietly shuts down a socket without throwing an exception . | train | false |
22,650 | def random_state_data(n, random_state=None):
import numpy as np
if (not isinstance(random_state, np.random.RandomState)):
random_state = np.random.RandomState(random_state)
maxuint32 = np.iinfo(np.uint32).max
return [(random_state.rand(624) * maxuint32).astype('uint32') for i in range(n)]
| [
"def",
"random_state_data",
"(",
"n",
",",
"random_state",
"=",
"None",
")",
":",
"import",
"numpy",
"as",
"np",
"if",
"(",
"not",
"isinstance",
"(",
"random_state",
",",
"np",
".",
"random",
".",
"RandomState",
")",
")",
":",
"random_state",
"=",
"np",
".",
"random",
".",
"RandomState",
"(",
"random_state",
")",
"maxuint32",
"=",
"np",
".",
"iinfo",
"(",
"np",
".",
"uint32",
")",
".",
"max",
"return",
"[",
"(",
"random_state",
".",
"rand",
"(",
"624",
")",
"*",
"maxuint32",
")",
".",
"astype",
"(",
"'uint32'",
")",
"for",
"i",
"in",
"range",
"(",
"n",
")",
"]"
] | return a list of arrays that can initialize np . | train | false |
22,652 | def _header_property(header):
def getter(self):
return self.headers.get(header, None)
def setter(self, value):
self.headers[header] = value
return property(getter, setter, doc=('Retrieve and set the %s header' % header))
| [
"def",
"_header_property",
"(",
"header",
")",
":",
"def",
"getter",
"(",
"self",
")",
":",
"return",
"self",
".",
"headers",
".",
"get",
"(",
"header",
",",
"None",
")",
"def",
"setter",
"(",
"self",
",",
"value",
")",
":",
"self",
".",
"headers",
"[",
"header",
"]",
"=",
"value",
"return",
"property",
"(",
"getter",
",",
"setter",
",",
"doc",
"=",
"(",
"'Retrieve and set the %s header'",
"%",
"header",
")",
")"
] | set and retrieve the value of self . | train | false |
22,653 | def setup_db_env():
global sa_logger, _IDLE_TIMEOUT, _MAX_RETRIES, _RETRY_INTERVAL, _CONNECTION
_IDLE_TIMEOUT = CONF.sql_idle_timeout
_MAX_RETRIES = CONF.sql_max_retries
_RETRY_INTERVAL = CONF.sql_retry_interval
_CONNECTION = CONF.sql_connection
sa_logger = logging.getLogger('sqlalchemy.engine')
if CONF.debug:
sa_logger.setLevel(logging.DEBUG)
| [
"def",
"setup_db_env",
"(",
")",
":",
"global",
"sa_logger",
",",
"_IDLE_TIMEOUT",
",",
"_MAX_RETRIES",
",",
"_RETRY_INTERVAL",
",",
"_CONNECTION",
"_IDLE_TIMEOUT",
"=",
"CONF",
".",
"sql_idle_timeout",
"_MAX_RETRIES",
"=",
"CONF",
".",
"sql_max_retries",
"_RETRY_INTERVAL",
"=",
"CONF",
".",
"sql_retry_interval",
"_CONNECTION",
"=",
"CONF",
".",
"sql_connection",
"sa_logger",
"=",
"logging",
".",
"getLogger",
"(",
"'sqlalchemy.engine'",
")",
"if",
"CONF",
".",
"debug",
":",
"sa_logger",
".",
"setLevel",
"(",
"logging",
".",
"DEBUG",
")"
] | setup configuration for database . | train | false |
22,655 | @transaction.non_atomic_requests
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
@require_global_staff
@require_POST
def start_certificate_regeneration(request, course_id):
course_key = CourseKey.from_string(course_id)
certificates_statuses = request.POST.getlist('certificate_statuses', [])
if (not certificates_statuses):
return JsonResponse({'message': _('Please select one or more certificate statuses that require certificate regeneration.')}, status=400)
allowed_statuses = [CertificateStatuses.downloadable, CertificateStatuses.error, CertificateStatuses.notpassing, CertificateStatuses.audit_passing, CertificateStatuses.audit_notpassing]
if (not set(certificates_statuses).issubset(allowed_statuses)):
return JsonResponse({'message': _('Please select certificate statuses from the list only.')}, status=400)
try:
lms.djangoapps.instructor_task.api.regenerate_certificates(request, course_key, certificates_statuses)
except AlreadyRunningError as error:
return JsonResponse({'message': error.message}, status=400)
response_payload = {'message': _('Certificate regeneration task has been started. You can view the status of the generation task in the "Pending Tasks" section.'), 'success': True}
return JsonResponse(response_payload)
| [
"@",
"transaction",
".",
"non_atomic_requests",
"@",
"ensure_csrf_cookie",
"@",
"cache_control",
"(",
"no_cache",
"=",
"True",
",",
"no_store",
"=",
"True",
",",
"must_revalidate",
"=",
"True",
")",
"@",
"require_global_staff",
"@",
"require_POST",
"def",
"start_certificate_regeneration",
"(",
"request",
",",
"course_id",
")",
":",
"course_key",
"=",
"CourseKey",
".",
"from_string",
"(",
"course_id",
")",
"certificates_statuses",
"=",
"request",
".",
"POST",
".",
"getlist",
"(",
"'certificate_statuses'",
",",
"[",
"]",
")",
"if",
"(",
"not",
"certificates_statuses",
")",
":",
"return",
"JsonResponse",
"(",
"{",
"'message'",
":",
"_",
"(",
"'Please select one or more certificate statuses that require certificate regeneration.'",
")",
"}",
",",
"status",
"=",
"400",
")",
"allowed_statuses",
"=",
"[",
"CertificateStatuses",
".",
"downloadable",
",",
"CertificateStatuses",
".",
"error",
",",
"CertificateStatuses",
".",
"notpassing",
",",
"CertificateStatuses",
".",
"audit_passing",
",",
"CertificateStatuses",
".",
"audit_notpassing",
"]",
"if",
"(",
"not",
"set",
"(",
"certificates_statuses",
")",
".",
"issubset",
"(",
"allowed_statuses",
")",
")",
":",
"return",
"JsonResponse",
"(",
"{",
"'message'",
":",
"_",
"(",
"'Please select certificate statuses from the list only.'",
")",
"}",
",",
"status",
"=",
"400",
")",
"try",
":",
"lms",
".",
"djangoapps",
".",
"instructor_task",
".",
"api",
".",
"regenerate_certificates",
"(",
"request",
",",
"course_key",
",",
"certificates_statuses",
")",
"except",
"AlreadyRunningError",
"as",
"error",
":",
"return",
"JsonResponse",
"(",
"{",
"'message'",
":",
"error",
".",
"message",
"}",
",",
"status",
"=",
"400",
")",
"response_payload",
"=",
"{",
"'message'",
":",
"_",
"(",
"'Certificate regeneration task has been started. You can view the status of the generation task in the \"Pending Tasks\" section.'",
")",
",",
"'success'",
":",
"True",
"}",
"return",
"JsonResponse",
"(",
"response_payload",
")"
] | start regenerating certificates for students whose certificate statuses lie with in certificate_statuses entry in post data . | train | false |
22,657 | def addEdgePair(edgePairTable, edges, faceEdgeIndex, remainingEdgeIndex, remainingEdgeTable):
if (faceEdgeIndex == remainingEdgeIndex):
return
if (not (faceEdgeIndex in remainingEdgeTable)):
return
edgePair = EdgePair().getFromIndexesEdges([remainingEdgeIndex, faceEdgeIndex], edges)
edgePairTable[str(edgePair)] = edgePair
| [
"def",
"addEdgePair",
"(",
"edgePairTable",
",",
"edges",
",",
"faceEdgeIndex",
",",
"remainingEdgeIndex",
",",
"remainingEdgeTable",
")",
":",
"if",
"(",
"faceEdgeIndex",
"==",
"remainingEdgeIndex",
")",
":",
"return",
"if",
"(",
"not",
"(",
"faceEdgeIndex",
"in",
"remainingEdgeTable",
")",
")",
":",
"return",
"edgePair",
"=",
"EdgePair",
"(",
")",
".",
"getFromIndexesEdges",
"(",
"[",
"remainingEdgeIndex",
",",
"faceEdgeIndex",
"]",
",",
"edges",
")",
"edgePairTable",
"[",
"str",
"(",
"edgePair",
")",
"]",
"=",
"edgePair"
] | add edge pair to the edge pair table . | train | false |
22,658 | @register.filter
def css_class(field):
return field.field.widget.__class__.__name__.lower()
| [
"@",
"register",
".",
"filter",
"def",
"css_class",
"(",
"field",
")",
":",
"return",
"field",
".",
"field",
".",
"widget",
".",
"__class__",
".",
"__name__",
".",
"lower",
"(",
")"
] | returns widgets class name in lowercase . | train | false |
22,660 | def seq_allequal(seq1, seq2):
if (seq1 is None):
return (seq2 is None)
if (seq2 is None):
return False
if (len(seq1) != len(seq2)):
return False
return npy.alltrue(npy.equal(seq1, seq2))
| [
"def",
"seq_allequal",
"(",
"seq1",
",",
"seq2",
")",
":",
"if",
"(",
"seq1",
"is",
"None",
")",
":",
"return",
"(",
"seq2",
"is",
"None",
")",
"if",
"(",
"seq2",
"is",
"None",
")",
":",
"return",
"False",
"if",
"(",
"len",
"(",
"seq1",
")",
"!=",
"len",
"(",
"seq2",
")",
")",
":",
"return",
"False",
"return",
"npy",
".",
"alltrue",
"(",
"npy",
".",
"equal",
"(",
"seq1",
",",
"seq2",
")",
")"
] | seq1 and seq2 are either none or sequences or numerix arrays return true if both are none or both are seqs with identical elements . | train | false |
22,661 | def convert_repr_number(number):
sep = ''
dec = ''
part_one = '0'
part_two = ''
for digit in number:
if digit.isdigit():
if (sep == ''):
part_one += digit
else:
part_two += digit
elif ((digit == '-') and (part_one == '0')):
part_one = '-0'
elif ((sep == '') and (sep != digit)):
sep = digit
elif (dec == ''):
dec = digit
part_two += '.'
else:
return False
if (dec == ''):
return float(('%s.%s' % (part_one, part_two)))
else:
return float(('%s%s' % (part_one, part_two)))
| [
"def",
"convert_repr_number",
"(",
"number",
")",
":",
"sep",
"=",
"''",
"dec",
"=",
"''",
"part_one",
"=",
"'0'",
"part_two",
"=",
"''",
"for",
"digit",
"in",
"number",
":",
"if",
"digit",
".",
"isdigit",
"(",
")",
":",
"if",
"(",
"sep",
"==",
"''",
")",
":",
"part_one",
"+=",
"digit",
"else",
":",
"part_two",
"+=",
"digit",
"elif",
"(",
"(",
"digit",
"==",
"'-'",
")",
"and",
"(",
"part_one",
"==",
"'0'",
")",
")",
":",
"part_one",
"=",
"'-0'",
"elif",
"(",
"(",
"sep",
"==",
"''",
")",
"and",
"(",
"sep",
"!=",
"digit",
")",
")",
":",
"sep",
"=",
"digit",
"elif",
"(",
"dec",
"==",
"''",
")",
":",
"dec",
"=",
"digit",
"part_two",
"+=",
"'.'",
"else",
":",
"return",
"False",
"if",
"(",
"dec",
"==",
"''",
")",
":",
"return",
"float",
"(",
"(",
"'%s.%s'",
"%",
"(",
"part_one",
",",
"part_two",
")",
")",
")",
"else",
":",
"return",
"float",
"(",
"(",
"'%s%s'",
"%",
"(",
"part_one",
",",
"part_two",
")",
")",
")"
] | helper function to convert a string representation back to a number . | train | false |
22,662 | def EntityListKind(keylist):
kinds = map(EntityKind, keylist)
unique_kinds = set(kinds)
numkinds = len(unique_kinds)
if (numkinds > 1):
return 'Multi'
elif (numkinds == 1):
return unique_kinds.pop()
else:
return 'None'
| [
"def",
"EntityListKind",
"(",
"keylist",
")",
":",
"kinds",
"=",
"map",
"(",
"EntityKind",
",",
"keylist",
")",
"unique_kinds",
"=",
"set",
"(",
"kinds",
")",
"numkinds",
"=",
"len",
"(",
"unique_kinds",
")",
"if",
"(",
"numkinds",
">",
"1",
")",
":",
"return",
"'Multi'",
"elif",
"(",
"numkinds",
"==",
"1",
")",
":",
"return",
"unique_kinds",
".",
"pop",
"(",
")",
"else",
":",
"return",
"'None'"
] | given list of entity keys . | train | false |
22,663 | def shell_quote(text):
return u"\\'".join(((u"'%s'" % p) for p in text.split(u"'")))
| [
"def",
"shell_quote",
"(",
"text",
")",
":",
"return",
"u\"\\\\'\"",
".",
"join",
"(",
"(",
"(",
"u\"'%s'\"",
"%",
"p",
")",
"for",
"p",
"in",
"text",
".",
"split",
"(",
"u\"'\"",
")",
")",
")"
] | quote text for inserting into a shell . | train | false |
22,665 | def create_reg_numbers(flow_params):
_replace_register(flow_params, ovsfw_consts.REG_PORT, 'reg_port')
_replace_register(flow_params, ovsfw_consts.REG_NET, 'reg_net')
| [
"def",
"create_reg_numbers",
"(",
"flow_params",
")",
":",
"_replace_register",
"(",
"flow_params",
",",
"ovsfw_consts",
".",
"REG_PORT",
",",
"'reg_port'",
")",
"_replace_register",
"(",
"flow_params",
",",
"ovsfw_consts",
".",
"REG_NET",
",",
"'reg_net'",
")"
] | replace reg_ values with defined register numbers . | train | false |
22,666 | def test_protocol0_regression():
brick = Linear(5, 10)
brick.allocate()
buf = BytesIO()
dump(brick, buf, parameters=list(brick.parameters), protocol=0)
try:
load(buf)
except TypeError:
assert False
| [
"def",
"test_protocol0_regression",
"(",
")",
":",
"brick",
"=",
"Linear",
"(",
"5",
",",
"10",
")",
"brick",
".",
"allocate",
"(",
")",
"buf",
"=",
"BytesIO",
"(",
")",
"dump",
"(",
"brick",
",",
"buf",
",",
"parameters",
"=",
"list",
"(",
"brick",
".",
"parameters",
")",
",",
"protocol",
"=",
"0",
")",
"try",
":",
"load",
"(",
"buf",
")",
"except",
"TypeError",
":",
"assert",
"False"
] | check for a regression where protocol 0 dumps fail on load . | train | false |
22,668 | def test_exit_on_collection_error(testdir):
testdir.makepyfile(**COLLECTION_ERROR_PY_FILES)
res = testdir.runpytest()
assert (res.ret == 2)
res.stdout.fnmatch_lines(['collected 2 items / 2 errors', '*ERROR collecting test_02_import_error.py*', '*No module named *asdfa*', '*ERROR collecting test_03_import_error.py*', '*No module named *asdfa*'])
| [
"def",
"test_exit_on_collection_error",
"(",
"testdir",
")",
":",
"testdir",
".",
"makepyfile",
"(",
"**",
"COLLECTION_ERROR_PY_FILES",
")",
"res",
"=",
"testdir",
".",
"runpytest",
"(",
")",
"assert",
"(",
"res",
".",
"ret",
"==",
"2",
")",
"res",
".",
"stdout",
".",
"fnmatch_lines",
"(",
"[",
"'collected 2 items / 2 errors'",
",",
"'*ERROR collecting test_02_import_error.py*'",
",",
"'*No module named *asdfa*'",
",",
"'*ERROR collecting test_03_import_error.py*'",
",",
"'*No module named *asdfa*'",
"]",
")"
] | verify that all collection errors are collected and no tests executed . | train | false |
22,670 | def _transform_result(typ, result):
if issubclass(typ, bytes):
return tostring(result, encoding='utf-8')
elif issubclass(typ, unicode):
return tostring(result, encoding='unicode')
else:
return result
| [
"def",
"_transform_result",
"(",
"typ",
",",
"result",
")",
":",
"if",
"issubclass",
"(",
"typ",
",",
"bytes",
")",
":",
"return",
"tostring",
"(",
"result",
",",
"encoding",
"=",
"'utf-8'",
")",
"elif",
"issubclass",
"(",
"typ",
",",
"unicode",
")",
":",
"return",
"tostring",
"(",
"result",
",",
"encoding",
"=",
"'unicode'",
")",
"else",
":",
"return",
"result"
] | convert the result back into the input type . | train | true |
22,673 | def output_list_inventory(json_output):
print json.dumps(json_output)
| [
"def",
"output_list_inventory",
"(",
"json_output",
")",
":",
"print",
"json",
".",
"dumps",
"(",
"json_output",
")"
] | output the --list data structure as json . | train | false |
22,674 | def ValidatePropertyString(name, value):
ValidateStringLength(name, value, max_len=_MAX_STRING_LENGTH)
| [
"def",
"ValidatePropertyString",
"(",
"name",
",",
"value",
")",
":",
"ValidateStringLength",
"(",
"name",
",",
"value",
",",
"max_len",
"=",
"_MAX_STRING_LENGTH",
")"
] | validates the length of an indexed string property . | train | false |
22,675 | def get_vmvalue_from_procfs(vmkey='VmSize', pid=None):
if (pid is None):
pid = os.getpid()
try:
t = open(('/proc/%d/status' % pid))
except IOError:
raise RuntimeError('/proc filesystem not supported')
if (sys.platform == 'sunos5'):
return _vmvalue_solaris(vmkey, pid)
else:
v = t.read()
t.close()
i = v.index((vmkey + ':'))
v = v[i:].split(None, 3)
if (len(v) < 3):
return 0
return (int(v[1]) * _vmvalue_scale[v[2]])
| [
"def",
"get_vmvalue_from_procfs",
"(",
"vmkey",
"=",
"'VmSize'",
",",
"pid",
"=",
"None",
")",
":",
"if",
"(",
"pid",
"is",
"None",
")",
":",
"pid",
"=",
"os",
".",
"getpid",
"(",
")",
"try",
":",
"t",
"=",
"open",
"(",
"(",
"'/proc/%d/status'",
"%",
"pid",
")",
")",
"except",
"IOError",
":",
"raise",
"RuntimeError",
"(",
"'/proc filesystem not supported'",
")",
"if",
"(",
"sys",
".",
"platform",
"==",
"'sunos5'",
")",
":",
"return",
"_vmvalue_solaris",
"(",
"vmkey",
",",
"pid",
")",
"else",
":",
"v",
"=",
"t",
".",
"read",
"(",
")",
"t",
".",
"close",
"(",
")",
"i",
"=",
"v",
".",
"index",
"(",
"(",
"vmkey",
"+",
"':'",
")",
")",
"v",
"=",
"v",
"[",
"i",
":",
"]",
".",
"split",
"(",
"None",
",",
"3",
")",
"if",
"(",
"len",
"(",
"v",
")",
"<",
"3",
")",
":",
"return",
"0",
"return",
"(",
"int",
"(",
"v",
"[",
"1",
"]",
")",
"*",
"_vmvalue_scale",
"[",
"v",
"[",
"2",
"]",
"]",
")"
] | return virtual memory value for the given pid using the /proc filesystem . | train | false |
22,677 | def TextAfterCursor():
return ToUnicode(vim.current.line[CurrentColumn():])
| [
"def",
"TextAfterCursor",
"(",
")",
":",
"return",
"ToUnicode",
"(",
"vim",
".",
"current",
".",
"line",
"[",
"CurrentColumn",
"(",
")",
":",
"]",
")"
] | returns the text after currentcolumn . | train | false |
22,678 | def register_models(engine):
models = (Artifact, ArtifactTag, ArtifactProperty, ArtifactBlob, ArtifactBlobLocation, ArtifactDependency)
for model in models:
model.metadata.create_all(engine)
| [
"def",
"register_models",
"(",
"engine",
")",
":",
"models",
"=",
"(",
"Artifact",
",",
"ArtifactTag",
",",
"ArtifactProperty",
",",
"ArtifactBlob",
",",
"ArtifactBlobLocation",
",",
"ArtifactDependency",
")",
"for",
"model",
"in",
"models",
":",
"model",
".",
"metadata",
".",
"create_all",
"(",
"engine",
")"
] | register models and create metadata . | train | false |
22,679 | @require_http_methods(['GET'])
@login_required
def user_verification_status(request):
course_id = request.GET.get('course_id', None)
if (course_id is None):
return HttpResponseBadRequest()
course_key = CourseLocator.from_string(course_id)
(enrollment_mode, __) = CourseEnrollment.enrollment_mode_for_user(request.user, course_key)
is_verification_required = (enrollment_mode in CourseMode.VERIFIED_MODES)
return JsonResponse({'is_verification_required': is_verification_required})
| [
"@",
"require_http_methods",
"(",
"[",
"'GET'",
"]",
")",
"@",
"login_required",
"def",
"user_verification_status",
"(",
"request",
")",
":",
"course_id",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'course_id'",
",",
"None",
")",
"if",
"(",
"course_id",
"is",
"None",
")",
":",
"return",
"HttpResponseBadRequest",
"(",
")",
"course_key",
"=",
"CourseLocator",
".",
"from_string",
"(",
"course_id",
")",
"(",
"enrollment_mode",
",",
"__",
")",
"=",
"CourseEnrollment",
".",
"enrollment_mode_for_user",
"(",
"request",
".",
"user",
",",
"course_key",
")",
"is_verification_required",
"=",
"(",
"enrollment_mode",
"in",
"CourseMode",
".",
"VERIFIED_MODES",
")",
"return",
"JsonResponse",
"(",
"{",
"'is_verification_required'",
":",
"is_verification_required",
"}",
")"
] | check for user verification status . | train | false |
22,680 | def cp_cmp(c, d):
zero = Polyn(c[2]).ring.zero
c0 = lbp(c[0], zero, Num(c[2]))
d0 = lbp(d[0], zero, Num(d[2]))
r = lbp_cmp(c0, d0)
if (r == (-1)):
return (-1)
if (r == 0):
c1 = lbp(c[3], zero, Num(c[5]))
d1 = lbp(d[3], zero, Num(d[5]))
r = lbp_cmp(c1, d1)
if (r == (-1)):
return (-1)
return 1
| [
"def",
"cp_cmp",
"(",
"c",
",",
"d",
")",
":",
"zero",
"=",
"Polyn",
"(",
"c",
"[",
"2",
"]",
")",
".",
"ring",
".",
"zero",
"c0",
"=",
"lbp",
"(",
"c",
"[",
"0",
"]",
",",
"zero",
",",
"Num",
"(",
"c",
"[",
"2",
"]",
")",
")",
"d0",
"=",
"lbp",
"(",
"d",
"[",
"0",
"]",
",",
"zero",
",",
"Num",
"(",
"d",
"[",
"2",
"]",
")",
")",
"r",
"=",
"lbp_cmp",
"(",
"c0",
",",
"d0",
")",
"if",
"(",
"r",
"==",
"(",
"-",
"1",
")",
")",
":",
"return",
"(",
"-",
"1",
")",
"if",
"(",
"r",
"==",
"0",
")",
":",
"c1",
"=",
"lbp",
"(",
"c",
"[",
"3",
"]",
",",
"zero",
",",
"Num",
"(",
"c",
"[",
"5",
"]",
")",
")",
"d1",
"=",
"lbp",
"(",
"d",
"[",
"3",
"]",
",",
"zero",
",",
"Num",
"(",
"d",
"[",
"5",
"]",
")",
")",
"r",
"=",
"lbp_cmp",
"(",
"c1",
",",
"d1",
")",
"if",
"(",
"r",
"==",
"(",
"-",
"1",
")",
")",
":",
"return",
"(",
"-",
"1",
")",
"return",
"1"
] | compare two critical pairs c and d . | train | false |
22,681 | def lookup_ssh_host_config(hostname, config):
return config.lookup(hostname)
| [
"def",
"lookup_ssh_host_config",
"(",
"hostname",
",",
"config",
")",
":",
"return",
"config",
".",
"lookup",
"(",
"hostname",
")"
] | provided only as a backward-compatible wrapper around . | train | false |
22,682 | @register_canonicalize
@register_specialize
@gof.local_optimizer([T.Elemwise])
def local_func_inv(node):
inv_pairs = ((basic.Deg2Rad, basic.Rad2Deg), (basic.Cosh, basic.ArcCosh), (basic.Tanh, basic.ArcTanh), (basic.Sinh, basic.ArcSinh), (basic.Conj, basic.Conj), (basic.Neg, basic.Neg), (basic.Inv, basic.Inv))
x = node.inputs[0]
if (not isinstance(node.op, T.Elemwise)):
return
if ((not x.owner) or (not isinstance(x.owner.op, T.Elemwise))):
return
prev_op = x.owner.op.scalar_op
node_op = node.op.scalar_op
for inv_pair in inv_pairs:
if is_inverse_pair(node_op, prev_op, inv_pair):
return x.owner.inputs
return
| [
"@",
"register_canonicalize",
"@",
"register_specialize",
"@",
"gof",
".",
"local_optimizer",
"(",
"[",
"T",
".",
"Elemwise",
"]",
")",
"def",
"local_func_inv",
"(",
"node",
")",
":",
"inv_pairs",
"=",
"(",
"(",
"basic",
".",
"Deg2Rad",
",",
"basic",
".",
"Rad2Deg",
")",
",",
"(",
"basic",
".",
"Cosh",
",",
"basic",
".",
"ArcCosh",
")",
",",
"(",
"basic",
".",
"Tanh",
",",
"basic",
".",
"ArcTanh",
")",
",",
"(",
"basic",
".",
"Sinh",
",",
"basic",
".",
"ArcSinh",
")",
",",
"(",
"basic",
".",
"Conj",
",",
"basic",
".",
"Conj",
")",
",",
"(",
"basic",
".",
"Neg",
",",
"basic",
".",
"Neg",
")",
",",
"(",
"basic",
".",
"Inv",
",",
"basic",
".",
"Inv",
")",
")",
"x",
"=",
"node",
".",
"inputs",
"[",
"0",
"]",
"if",
"(",
"not",
"isinstance",
"(",
"node",
".",
"op",
",",
"T",
".",
"Elemwise",
")",
")",
":",
"return",
"if",
"(",
"(",
"not",
"x",
".",
"owner",
")",
"or",
"(",
"not",
"isinstance",
"(",
"x",
".",
"owner",
".",
"op",
",",
"T",
".",
"Elemwise",
")",
")",
")",
":",
"return",
"prev_op",
"=",
"x",
".",
"owner",
".",
"op",
".",
"scalar_op",
"node_op",
"=",
"node",
".",
"op",
".",
"scalar_op",
"for",
"inv_pair",
"in",
"inv_pairs",
":",
"if",
"is_inverse_pair",
"(",
"node_op",
",",
"prev_op",
",",
"inv_pair",
")",
":",
"return",
"x",
".",
"owner",
".",
"inputs",
"return"
] | check for two consecutive operations that are functional inverses and remove them from the function graph . | train | false |
22,683 | def create_egg(name, resources):
egg = imp.new_module(name)
egg.__loader__ = MockLoader()
egg._resources = resources
sys.modules[name] = egg
| [
"def",
"create_egg",
"(",
"name",
",",
"resources",
")",
":",
"egg",
"=",
"imp",
".",
"new_module",
"(",
"name",
")",
"egg",
".",
"__loader__",
"=",
"MockLoader",
"(",
")",
"egg",
".",
"_resources",
"=",
"resources",
"sys",
".",
"modules",
"[",
"name",
"]",
"=",
"egg"
] | creates a mock egg with a list of resources . | train | false |
22,684 | def map_qos_spec(qos_spec, volume):
if (qos_spec is None):
return None
qos_spec = map_dict_to_lower(qos_spec)
spec = dict(policy_name=get_qos_policy_group_name(volume), max_throughput=None)
if ('maxiops' in qos_spec):
spec['max_throughput'] = ('%siops' % qos_spec['maxiops'])
elif ('maxiopspergib' in qos_spec):
spec['max_throughput'] = ('%siops' % six.text_type((int(qos_spec['maxiopspergib']) * int(volume['size']))))
elif ('maxbps' in qos_spec):
spec['max_throughput'] = ('%sB/s' % qos_spec['maxbps'])
elif ('maxbpspergib' in qos_spec):
spec['max_throughput'] = ('%sB/s' % six.text_type((int(qos_spec['maxbpspergib']) * int(volume['size']))))
return spec
| [
"def",
"map_qos_spec",
"(",
"qos_spec",
",",
"volume",
")",
":",
"if",
"(",
"qos_spec",
"is",
"None",
")",
":",
"return",
"None",
"qos_spec",
"=",
"map_dict_to_lower",
"(",
"qos_spec",
")",
"spec",
"=",
"dict",
"(",
"policy_name",
"=",
"get_qos_policy_group_name",
"(",
"volume",
")",
",",
"max_throughput",
"=",
"None",
")",
"if",
"(",
"'maxiops'",
"in",
"qos_spec",
")",
":",
"spec",
"[",
"'max_throughput'",
"]",
"=",
"(",
"'%siops'",
"%",
"qos_spec",
"[",
"'maxiops'",
"]",
")",
"elif",
"(",
"'maxiopspergib'",
"in",
"qos_spec",
")",
":",
"spec",
"[",
"'max_throughput'",
"]",
"=",
"(",
"'%siops'",
"%",
"six",
".",
"text_type",
"(",
"(",
"int",
"(",
"qos_spec",
"[",
"'maxiopspergib'",
"]",
")",
"*",
"int",
"(",
"volume",
"[",
"'size'",
"]",
")",
")",
")",
")",
"elif",
"(",
"'maxbps'",
"in",
"qos_spec",
")",
":",
"spec",
"[",
"'max_throughput'",
"]",
"=",
"(",
"'%sB/s'",
"%",
"qos_spec",
"[",
"'maxbps'",
"]",
")",
"elif",
"(",
"'maxbpspergib'",
"in",
"qos_spec",
")",
":",
"spec",
"[",
"'max_throughput'",
"]",
"=",
"(",
"'%sB/s'",
"%",
"six",
".",
"text_type",
"(",
"(",
"int",
"(",
"qos_spec",
"[",
"'maxbpspergib'",
"]",
")",
"*",
"int",
"(",
"volume",
"[",
"'size'",
"]",
")",
")",
")",
")",
"return",
"spec"
] | map cinder qos spec to limit/throughput-value as used in client api . | train | false |
22,686 | def breadth_first(tree, children=iter, maxdepth=(-1)):
queue = deque([(tree, 0)])
while queue:
(node, depth) = queue.popleft()
(yield node)
if (depth != maxdepth):
try:
queue.extend(((c, (depth + 1)) for c in children(node)))
except TypeError:
pass
| [
"def",
"breadth_first",
"(",
"tree",
",",
"children",
"=",
"iter",
",",
"maxdepth",
"=",
"(",
"-",
"1",
")",
")",
":",
"queue",
"=",
"deque",
"(",
"[",
"(",
"tree",
",",
"0",
")",
"]",
")",
"while",
"queue",
":",
"(",
"node",
",",
"depth",
")",
"=",
"queue",
".",
"popleft",
"(",
")",
"(",
"yield",
"node",
")",
"if",
"(",
"depth",
"!=",
"maxdepth",
")",
":",
"try",
":",
"queue",
".",
"extend",
"(",
"(",
"(",
"c",
",",
"(",
"depth",
"+",
"1",
")",
")",
"for",
"c",
"in",
"children",
"(",
"node",
")",
")",
")",
"except",
"TypeError",
":",
"pass"
] | traverse the nodes of a tree in breadth-first order . | train | false |
22,687 | @deprecated_network
def do_dns_domains(cs, args):
domains = cs.dns_domains.domains()
_print_domain_list(domains)
| [
"@",
"deprecated_network",
"def",
"do_dns_domains",
"(",
"cs",
",",
"args",
")",
":",
"domains",
"=",
"cs",
".",
"dns_domains",
".",
"domains",
"(",
")",
"_print_domain_list",
"(",
"domains",
")"
] | print a list of available dns domains . | train | false |
22,690 | def test_no_data_with_empty_serie(Chart):
chart = Chart()
chart.add('Serie', [])
q = chart.render_pyquery()
assert (q('.text-overlay text').text() == 'No data')
| [
"def",
"test_no_data_with_empty_serie",
"(",
"Chart",
")",
":",
"chart",
"=",
"Chart",
"(",
")",
"chart",
".",
"add",
"(",
"'Serie'",
",",
"[",
"]",
")",
"q",
"=",
"chart",
".",
"render_pyquery",
"(",
")",
"assert",
"(",
"q",
"(",
"'.text-overlay text'",
")",
".",
"text",
"(",
")",
"==",
"'No data'",
")"
] | test no data for empty serie . | train | false |
22,692 | def vary_on_headers(*headers):
def decorator(func):
def inner_func(*args, **kwargs):
response = func(*args, **kwargs)
patch_vary_headers(response, headers)
return response
return wraps(func, assigned=available_attrs(func))(inner_func)
return decorator
| [
"def",
"vary_on_headers",
"(",
"*",
"headers",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"def",
"inner_func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"response",
"=",
"func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
"patch_vary_headers",
"(",
"response",
",",
"headers",
")",
"return",
"response",
"return",
"wraps",
"(",
"func",
",",
"assigned",
"=",
"available_attrs",
"(",
"func",
")",
")",
"(",
"inner_func",
")",
"return",
"decorator"
] | a view decorator that adds the specified headers to the vary header of the response . | train | false |
22,693 | def _get_application_url():
application_url = __salt__['pillar.get']('uptime:application_url')
if (application_url is None):
log.error('Could not load {0} pillar'.format('uptime:application_url'))
msg = '{0} pillar is required for authentication'
raise CommandExecutionError(msg.format('uptime:application_url'))
return application_url
| [
"def",
"_get_application_url",
"(",
")",
":",
"application_url",
"=",
"__salt__",
"[",
"'pillar.get'",
"]",
"(",
"'uptime:application_url'",
")",
"if",
"(",
"application_url",
"is",
"None",
")",
":",
"log",
".",
"error",
"(",
"'Could not load {0} pillar'",
".",
"format",
"(",
"'uptime:application_url'",
")",
")",
"msg",
"=",
"'{0} pillar is required for authentication'",
"raise",
"CommandExecutionError",
"(",
"msg",
".",
"format",
"(",
"'uptime:application_url'",
")",
")",
"return",
"application_url"
] | helper function to get application url from pillar . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.