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 |
|---|---|---|---|---|---|
53,222 | def numToDottedQuad(num):
import socket, struct
if ((num > long(4294967295)) or (num < 0)):
raise ValueError(('Not a good numeric IP: %s' % num))
try:
return socket.inet_ntoa(struct.pack('!L', long(num)))
except (socket.error, struct.error, OverflowError):
raise ValueError(('Not a good numeric IP: %s' % num))
| [
"def",
"numToDottedQuad",
"(",
"num",
")",
":",
"import",
"socket",
",",
"struct",
"if",
"(",
"(",
"num",
">",
"long",
"(",
"4294967295",
")",
")",
"or",
"(",
"num",
"<",
"0",
")",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'Not a good numeric IP: %s'... | convert int or long int to dotted quad string . | train | true |
53,223 | def delete_record(zone_id, record_id, profile):
conn = _get_driver(profile=profile)
record = conn.get_record(zone_id=zone_id, record_id=record_id)
return conn.delete_record(record)
| [
"def",
"delete_record",
"(",
"zone_id",
",",
"record_id",
",",
"profile",
")",
":",
"conn",
"=",
"_get_driver",
"(",
"profile",
"=",
"profile",
")",
"record",
"=",
"conn",
".",
"get_record",
"(",
"zone_id",
"=",
"zone_id",
",",
"record_id",
"=",
"record_id... | delete a record . | train | true |
53,224 | def queues(request):
return render('queues.html', request, {'queuelist': request.jt.queues()})
| [
"def",
"queues",
"(",
"request",
")",
":",
"return",
"render",
"(",
"'queues.html'",
",",
"request",
",",
"{",
"'queuelist'",
":",
"request",
".",
"jt",
".",
"queues",
"(",
")",
"}",
")"
] | we get here from /queues . | train | false |
53,226 | def json_objs_equal(left, right):
return (_ordered(left) == _ordered(right))
| [
"def",
"json_objs_equal",
"(",
"left",
",",
"right",
")",
":",
"return",
"(",
"_ordered",
"(",
"left",
")",
"==",
"_ordered",
"(",
"right",
")",
")"
] | compare two parsed json objects . | train | false |
53,227 | def restart_program():
logging.info('Scheduled restart request')
sabnzbd.TRIGGER_RESTART = True
| [
"def",
"restart_program",
"(",
")",
":",
"logging",
".",
"info",
"(",
"'Scheduled restart request'",
")",
"sabnzbd",
".",
"TRIGGER_RESTART",
"=",
"True"
] | restart program . | train | false |
53,229 | def process_failed(dirName, nzbName, result):
if sickbeard.USE_FAILED_DOWNLOADS:
processor = None
try:
processor = failedProcessor.FailedProcessor(dirName, nzbName)
result.result = processor.process()
process_fail_message = u''
except FailedPostProcessingFailedException as e:
result.result = False
process_fail_message = ex(e)
if processor:
result.output += processor.log
if (sickbeard.DELETE_FAILED and result.result):
if delete_folder(dirName, check_empty=False):
result.output += logHelper(u'Deleted folder: {0}'.format(dirName), logger.DEBUG)
if result.result:
result.output += logHelper(u'Failed Download Processing succeeded: ({0}, {1})'.format(nzbName, dirName))
else:
result.output += logHelper(u'Failed Download Processing failed: ({0}, {1}): {2}'.format(nzbName, dirName, process_fail_message), logger.WARNING)
| [
"def",
"process_failed",
"(",
"dirName",
",",
"nzbName",
",",
"result",
")",
":",
"if",
"sickbeard",
".",
"USE_FAILED_DOWNLOADS",
":",
"processor",
"=",
"None",
"try",
":",
"processor",
"=",
"failedProcessor",
".",
"FailedProcessor",
"(",
"dirName",
",",
"nzbN... | process a download that did not complete correctly . | train | false |
53,230 | @decorator.decorator
def apply_to_mask(f, clip, *a, **k):
newclip = f(clip, *a, **k)
if (hasattr(newclip, 'mask') and (newclip.mask is not None)):
newclip.mask = f(newclip.mask, *a, **k)
return newclip
| [
"@",
"decorator",
".",
"decorator",
"def",
"apply_to_mask",
"(",
"f",
",",
"clip",
",",
"*",
"a",
",",
"**",
"k",
")",
":",
"newclip",
"=",
"f",
"(",
"clip",
",",
"*",
"a",
",",
"**",
"k",
")",
"if",
"(",
"hasattr",
"(",
"newclip",
",",
"'mask'... | this decorator will apply the same function f to the mask of the clip created with f . | train | false |
53,231 | def whoisCallersCaller():
import inspect
frameObj = inspect.stack()[2][0]
return inspect.getframeinfo(frameObj)
| [
"def",
"whoisCallersCaller",
"(",
")",
":",
"import",
"inspect",
"frameObj",
"=",
"inspect",
".",
"stack",
"(",
")",
"[",
"2",
"]",
"[",
"0",
"]",
"return",
"inspect",
".",
"getframeinfo",
"(",
"frameObj",
")"
] | returns: traceback namedtuple for our callers caller . | train | false |
53,234 | def get_feedback(score, sequence):
global default_feedback
if (len(sequence) == 0):
return default_feedback
if (score > 2):
return dict({u'warning': u'', u'suggestions': []})
longest_match = max(sequence, key=(lambda x: len(x[u'token'])))
feedback = get_match_feedback(longest_match, (len(sequence) == 1))
if (not feedback):
feedback = {u'warning': u'', u'suggestions': [_(u'Better add a few more letters or another word')]}
return feedback
| [
"def",
"get_feedback",
"(",
"score",
",",
"sequence",
")",
":",
"global",
"default_feedback",
"if",
"(",
"len",
"(",
"sequence",
")",
"==",
"0",
")",
":",
"return",
"default_feedback",
"if",
"(",
"score",
">",
"2",
")",
":",
"return",
"dict",
"(",
"{",... | returns the feedback dictionary consisting of for the given sequences . | train | false |
53,235 | @click.command(u'bulk-rename')
@click.argument(u'doctype')
@click.argument(u'path')
@pass_context
def _bulk_rename(context, doctype, path):
from frappe.model.rename_doc import bulk_rename
from frappe.utils.csvutils import read_csv_content
site = get_site(context)
with open(path, u'r') as csvfile:
rows = read_csv_content(csvfile.read())
frappe.init(site=site)
frappe.connect()
bulk_rename(doctype, rows, via_console=True)
frappe.destroy()
| [
"@",
"click",
".",
"command",
"(",
"u'bulk-rename'",
")",
"@",
"click",
".",
"argument",
"(",
"u'doctype'",
")",
"@",
"click",
".",
"argument",
"(",
"u'path'",
")",
"@",
"pass_context",
"def",
"_bulk_rename",
"(",
"context",
",",
"doctype",
",",
"path",
... | rename multiple records via csv file . | train | false |
53,236 | def mocked_get_release_by_id(id_, includes=[], release_status=[], release_type=[]):
releases = {ImportMusicBrainzIdTest.ID_RELEASE_0: ('VALID_RELEASE_0', 'TAG ARTIST'), ImportMusicBrainzIdTest.ID_RELEASE_1: ('VALID_RELEASE_1', 'DISTANT_MATCH')}
return {'release': {'title': releases[id_][0], 'id': id_, 'medium-list': [{'track-list': [{'recording': {'title': 'foo', 'id': 'bar', 'length': 59}, 'position': 9, 'number': 'A2'}], 'position': 5}], 'artist-credit': [{'artist': {'name': releases[id_][1], 'id': 'some-id'}}], 'release-group': {'id': 'another-id'}}}
| [
"def",
"mocked_get_release_by_id",
"(",
"id_",
",",
"includes",
"=",
"[",
"]",
",",
"release_status",
"=",
"[",
"]",
",",
"release_type",
"=",
"[",
"]",
")",
":",
"releases",
"=",
"{",
"ImportMusicBrainzIdTest",
".",
"ID_RELEASE_0",
":",
"(",
"'VALID_RELEASE... | mimic musicbrainzngs . | train | false |
53,237 | def test_finder_only_installs_stable_releases(data):
req = InstallRequirement.from_line('bar', None)
finder = PackageFinder([], [data.index_url('pre')], session=PipSession())
link = finder.find_requirement(req, False)
assert link.url.endswith('bar-1.0.tar.gz'), link.url
links = ['https://foo/bar-1.0.tar.gz', 'https://foo/bar-2.0b1.tar.gz']
finder = PackageFinder(links, [], session=PipSession())
with patch.object(finder, '_get_pages', (lambda x, y: [])):
link = finder.find_requirement(req, False)
assert (link.url == 'https://foo/bar-1.0.tar.gz')
links.reverse()
finder = PackageFinder(links, [], session=PipSession())
with patch.object(finder, '_get_pages', (lambda x, y: [])):
link = finder.find_requirement(req, False)
assert (link.url == 'https://foo/bar-1.0.tar.gz')
| [
"def",
"test_finder_only_installs_stable_releases",
"(",
"data",
")",
":",
"req",
"=",
"InstallRequirement",
".",
"from_line",
"(",
"'bar'",
",",
"None",
")",
"finder",
"=",
"PackageFinder",
"(",
"[",
"]",
",",
"[",
"data",
".",
"index_url",
"(",
"'pre'",
")... | test packagefinder only accepts stable versioned releases by default . | train | false |
53,238 | @must_have_permission('write')
@must_have_addon(SHORT_NAME, 'user')
@must_have_addon(SHORT_NAME, 'node')
def dataverse_get_datasets(node_addon, **kwargs):
alias = request.json.get('alias')
connection = client.connect_from_settings(node_addon)
dataverse = client.get_dataverse(connection, alias)
datasets = client.get_datasets(dataverse)
ret = {'alias': alias, 'datasets': [{'title': dataset.title, 'doi': dataset.doi} for dataset in datasets]}
return (ret, http.OK)
| [
"@",
"must_have_permission",
"(",
"'write'",
")",
"@",
"must_have_addon",
"(",
"SHORT_NAME",
",",
"'user'",
")",
"@",
"must_have_addon",
"(",
"SHORT_NAME",
",",
"'node'",
")",
"def",
"dataverse_get_datasets",
"(",
"node_addon",
",",
"**",
"kwargs",
")",
":",
"... | get list of datasets from provided dataverse alias . | train | false |
53,239 | def _compute_row_norms(data):
norms = np.sqrt(np.sum((data ** 2), axis=1))
norms[(norms == 0)] = 1.0
return norms
| [
"def",
"_compute_row_norms",
"(",
"data",
")",
":",
"norms",
"=",
"np",
".",
"sqrt",
"(",
"np",
".",
"sum",
"(",
"(",
"data",
"**",
"2",
")",
",",
"axis",
"=",
"1",
")",
")",
"norms",
"[",
"(",
"norms",
"==",
"0",
")",
"]",
"=",
"1.0",
"retur... | compute scaling based on estimated norm . | train | false |
53,240 | def setval(key, val, destructive=False):
return setvals({key: val}, destructive)
| [
"def",
"setval",
"(",
"key",
",",
"val",
",",
"destructive",
"=",
"False",
")",
":",
"return",
"setvals",
"(",
"{",
"key",
":",
"val",
"}",
",",
"destructive",
")"
] | set a grains value in the grains config file key the grain key to be set . | train | false |
53,241 | def sortNDHelperA(fitnesses, obj, front):
if (len(fitnesses) < 2):
return
elif (len(fitnesses) == 2):
(s1, s2) = (fitnesses[0], fitnesses[1])
if isDominated(s2[:(obj + 1)], s1[:(obj + 1)]):
front[s2] = max(front[s2], (front[s1] + 1))
elif (obj == 1):
sweepA(fitnesses, front)
elif (len(frozenset(map(itemgetter(obj), fitnesses))) == 1):
sortNDHelperA(fitnesses, (obj - 1), front)
else:
(best, worst) = splitA(fitnesses, obj)
sortNDHelperA(best, obj, front)
sortNDHelperB(best, worst, (obj - 1), front)
sortNDHelperA(worst, obj, front)
| [
"def",
"sortNDHelperA",
"(",
"fitnesses",
",",
"obj",
",",
"front",
")",
":",
"if",
"(",
"len",
"(",
"fitnesses",
")",
"<",
"2",
")",
":",
"return",
"elif",
"(",
"len",
"(",
"fitnesses",
")",
"==",
"2",
")",
":",
"(",
"s1",
",",
"s2",
")",
"=",... | create a non-dominated sorting of s on the first m objectives . | train | false |
53,242 | def cxESBlend(ind1, ind2, alpha):
for (i, (x1, s1, x2, s2)) in enumerate(zip(ind1, ind1.strategy, ind2, ind2.strategy)):
gamma = (((1.0 + (2.0 * alpha)) * random.random()) - alpha)
ind1[i] = (((1.0 - gamma) * x1) + (gamma * x2))
ind2[i] = ((gamma * x1) + ((1.0 - gamma) * x2))
gamma = (((1.0 + (2.0 * alpha)) * random.random()) - alpha)
ind1.strategy[i] = (((1.0 - gamma) * s1) + (gamma * s2))
ind2.strategy[i] = ((gamma * s1) + ((1.0 - gamma) * s2))
return (ind1, ind2)
| [
"def",
"cxESBlend",
"(",
"ind1",
",",
"ind2",
",",
"alpha",
")",
":",
"for",
"(",
"i",
",",
"(",
"x1",
",",
"s1",
",",
"x2",
",",
"s2",
")",
")",
"in",
"enumerate",
"(",
"zip",
"(",
"ind1",
",",
"ind1",
".",
"strategy",
",",
"ind2",
",",
"ind... | executes a blend crossover on both . | train | false |
53,243 | def validate_encoding_and_error_handler(setting, value, option_parser, config_parser=None, config_section=None):
if (':' in value):
(encoding, handler) = value.split(':')
validate_encoding_error_handler((setting + '_error_handler'), handler, option_parser, config_parser, config_section)
if config_parser:
config_parser.set(config_section, (setting + '_error_handler'), handler)
else:
setattr(option_parser.values, (setting + '_error_handler'), handler)
else:
encoding = value
validate_encoding(setting, encoding, option_parser, config_parser, config_section)
return encoding
| [
"def",
"validate_encoding_and_error_handler",
"(",
"setting",
",",
"value",
",",
"option_parser",
",",
"config_parser",
"=",
"None",
",",
"config_section",
"=",
"None",
")",
":",
"if",
"(",
"':'",
"in",
"value",
")",
":",
"(",
"encoding",
",",
"handler",
")"... | side-effect: if an error handler is included in the value . | train | false |
53,244 | def extract_public_key(args):
sk = _load_key(args)
vk = sk.get_verifying_key()
args.public_keyfile.write(vk.to_string())
print ('%s public key extracted to %s' % (args.keyfile.name, args.public_keyfile.name))
| [
"def",
"extract_public_key",
"(",
"args",
")",
":",
"sk",
"=",
"_load_key",
"(",
"args",
")",
"vk",
"=",
"sk",
".",
"get_verifying_key",
"(",
")",
"args",
".",
"public_keyfile",
".",
"write",
"(",
"vk",
".",
"to_string",
"(",
")",
")",
"print",
"(",
... | load an ecdsa private key and extract the embedded public key as raw binary data . | train | true |
53,245 | def requires_reload(action, plugins):
return any((p.get_plugin_class_instance().requires_reload(action) for p in plugins))
| [
"def",
"requires_reload",
"(",
"action",
",",
"plugins",
")",
":",
"return",
"any",
"(",
"(",
"p",
".",
"get_plugin_class_instance",
"(",
")",
".",
"requires_reload",
"(",
"action",
")",
"for",
"p",
"in",
"plugins",
")",
")"
] | returns true if any of the plugins require a page reload when action is taking place . | train | false |
53,246 | def is_jinja_expression(value):
if ((not value) or (not isinstance(value, six.string_types))):
return False
for marker in JINJA_EXPRESSIONS_START_MARKERS:
if (marker in value):
return True
return False
| [
"def",
"is_jinja_expression",
"(",
"value",
")",
":",
"if",
"(",
"(",
"not",
"value",
")",
"or",
"(",
"not",
"isinstance",
"(",
"value",
",",
"six",
".",
"string_types",
")",
")",
")",
":",
"return",
"False",
"for",
"marker",
"in",
"JINJA_EXPRESSIONS_STA... | function which very simplisticly detect if the provided value contains or is a jinja expression . | train | false |
53,248 | @preloaderStop
def failureMessage(message):
printLine(message, '\n', sys.stderr)
| [
"@",
"preloaderStop",
"def",
"failureMessage",
"(",
"message",
")",
":",
"printLine",
"(",
"message",
",",
"'\\n'",
",",
"sys",
".",
"stderr",
")"
] | displaying a message . | train | false |
53,249 | @require_POST
@login_required
def watch_document(request, document_slug):
document = get_object_or_404(Document, locale=request.LANGUAGE_CODE, slug=document_slug)
EditDocumentEvent.notify(request.user, document)
statsd.incr('wiki.watches.document')
return HttpResponseRedirect(document.get_absolute_url())
| [
"@",
"require_POST",
"@",
"login_required",
"def",
"watch_document",
"(",
"request",
",",
"document_slug",
")",
":",
"document",
"=",
"get_object_or_404",
"(",
"Document",
",",
"locale",
"=",
"request",
".",
"LANGUAGE_CODE",
",",
"slug",
"=",
"document_slug",
")... | start watching a document for edits . | train | false |
53,251 | @auth.errorhandler(429)
def login_rate_limit_error(error):
return render_template('errors/too_many_logins.html', timeout=error.description)
| [
"@",
"auth",
".",
"errorhandler",
"(",
"429",
")",
"def",
"login_rate_limit_error",
"(",
"error",
")",
":",
"return",
"render_template",
"(",
"'errors/too_many_logins.html'",
",",
"timeout",
"=",
"error",
".",
"description",
")"
] | register a custom error handler for a too many requests error . | train | false |
53,252 | def migration_get_in_progress_by_host_and_node(context, host, node):
return IMPL.migration_get_in_progress_by_host_and_node(context, host, node)
| [
"def",
"migration_get_in_progress_by_host_and_node",
"(",
"context",
",",
"host",
",",
"node",
")",
":",
"return",
"IMPL",
".",
"migration_get_in_progress_by_host_and_node",
"(",
"context",
",",
"host",
",",
"node",
")"
] | finds all migrations for the given host + node that are not yet confirmed or reverted . | train | false |
53,253 | def _check_throttles_decorator(func):
@wraps(func)
def _decorated(*args, **kwargs):
if RateLimitConfiguration.current().enabled:
return func(*args, **kwargs)
else:
msg = 'Rate limiting is disabled because `RateLimitConfiguration` is not enabled.'
LOGGER.info(msg)
return
return _decorated
| [
"def",
"_check_throttles_decorator",
"(",
"func",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"_decorated",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"RateLimitConfiguration",
".",
"current",
"(",
")",
".",
"enabled",
":",
"return",
"fu... | decorator for apiview . | train | false |
53,255 | def raise_config_error(key, dummy):
raise ConfigurationError(('Unknown option %s' % (key,)))
| [
"def",
"raise_config_error",
"(",
"key",
",",
"dummy",
")",
":",
"raise",
"ConfigurationError",
"(",
"(",
"'Unknown option %s'",
"%",
"(",
"key",
",",
")",
")",
")"
] | raise configurationerror with the given key name . | train | false |
53,256 | def read_has_prefix(path):
ParseResult = namedtuple(u'ParseResult', (u'placeholder', u'filemode', u'filepath'))
def parse_line(line):
parts = tuple((x.strip(u'"\'') for x in shlex.split(line, posix=False)))
if (len(parts) == 1):
return ParseResult(PREFIX_PLACEHOLDER, FileMode.text, parts[0])
elif (len(parts) == 3):
return ParseResult(parts[0], FileMode(parts[1]), parts[2])
else:
raise RuntimeError((u'Invalid has_prefix file at path: %s' % path))
parsed_lines = (parse_line(line) for line in yield_lines(path))
return {pr.filepath: (pr.placeholder, pr.filemode) for pr in parsed_lines}
| [
"def",
"read_has_prefix",
"(",
"path",
")",
":",
"ParseResult",
"=",
"namedtuple",
"(",
"u'ParseResult'",
",",
"(",
"u'placeholder'",
",",
"u'filemode'",
",",
"u'filepath'",
")",
")",
"def",
"parse_line",
"(",
"line",
")",
":",
"parts",
"=",
"tuple",
"(",
... | reads has_prefix file and return dict mapping filepaths to tuples a line in has_prefix contains one of * filepath * placeholder mode filepath mode values are one of * text * binary . | train | false |
53,258 | @_np.deprecate(message='scipy.constants.K2F is deprecated in scipy 0.18.0. Use scipy.constants.convert_temperature instead. Note that the new function has a different signature.')
def K2F(K):
return C2F(K2C(_np.asanyarray(K)))
| [
"@",
"_np",
".",
"deprecate",
"(",
"message",
"=",
"'scipy.constants.K2F is deprecated in scipy 0.18.0. Use scipy.constants.convert_temperature instead. Note that the new function has a different signature.'",
")",
"def",
"K2F",
"(",
"K",
")",
":",
"return",
"C2F",
"(",
"K2C",
... | convert kelvin to fahrenheit parameters k : array_like kelvin temperature(s) to be converted . | train | false |
53,260 | def decode_terminated(data, encoding, strict=True):
codec_info = codecs.lookup(encoding)
encoding = codec_info.name
if (encoding in ('utf-8', 'iso8859-1')):
index = data.find('\x00')
if (index == (-1)):
res = (data.decode(encoding), '')
if strict:
raise ValueError('not null terminated')
else:
return res
return (data[:index].decode(encoding), data[(index + 1):])
decoder = codec_info.incrementaldecoder()
r = []
for (i, b) in enumerate(iterbytes(data)):
c = decoder.decode(b)
if (c == u'\x00'):
return (u''.join(r), data[(i + 1):])
r.append(c)
else:
r.append(decoder.decode('', True))
if strict:
raise ValueError('not null terminated')
return (u''.join(r), '')
| [
"def",
"decode_terminated",
"(",
"data",
",",
"encoding",
",",
"strict",
"=",
"True",
")",
":",
"codec_info",
"=",
"codecs",
".",
"lookup",
"(",
"encoding",
")",
"encoding",
"=",
"codec_info",
".",
"name",
"if",
"(",
"encoding",
"in",
"(",
"'utf-8'",
","... | returns the decoded data until the first null terminator and all data after it . | train | true |
53,261 | def rfc822_escape(header):
lines = header.split('\n')
sep = ('\n' + (8 * ' '))
return sep.join(lines)
| [
"def",
"rfc822_escape",
"(",
"header",
")",
":",
"lines",
"=",
"header",
".",
"split",
"(",
"'\\n'",
")",
"sep",
"=",
"(",
"'\\n'",
"+",
"(",
"8",
"*",
"' '",
")",
")",
"return",
"sep",
".",
"join",
"(",
"lines",
")"
] | return a version of the string escaped for inclusion in an rfc-822 header . | train | false |
53,263 | def wrap_file(environ, file, buffer_size=8192):
return environ.get('wsgi.file_wrapper', FileWrapper)(file, buffer_size)
| [
"def",
"wrap_file",
"(",
"environ",
",",
"file",
",",
"buffer_size",
"=",
"8192",
")",
":",
"return",
"environ",
".",
"get",
"(",
"'wsgi.file_wrapper'",
",",
"FileWrapper",
")",
"(",
"file",
",",
"buffer_size",
")"
] | wraps a file . | train | false |
53,264 | def _encode_float(name, value, dummy0, dummy1):
return (('\x01' + name) + _PACK_FLOAT(value))
| [
"def",
"_encode_float",
"(",
"name",
",",
"value",
",",
"dummy0",
",",
"dummy1",
")",
":",
"return",
"(",
"(",
"'\\x01'",
"+",
"name",
")",
"+",
"_PACK_FLOAT",
"(",
"value",
")",
")"
] | encode a float . | train | false |
53,266 | def _set_controls(coordinator, root, namespace):
namespaces = {'n': namespace}
controls_list = root.xpath('n:controls', namespaces=namespaces)
if controls_list:
controls = controls_list[0]
concurrency = controls.xpath('n:concurrency', namespaces=namespaces)
timeout = controls.xpath('n:timeout', namespaces=namespaces)
execution = controls.xpath('n:execution', namespaces=namespaces)
throttle = controls.xpath('n:throttle', namespaces=namespaces)
if concurrency:
coordinator.concurrency = concurrency[0].text
if timeout:
coordinator.timeout = timeout[0].text
if execution:
coordinator.execution = execution[0].text
if throttle:
coordinator.throttle = throttle[0].text
| [
"def",
"_set_controls",
"(",
"coordinator",
",",
"root",
",",
"namespace",
")",
":",
"namespaces",
"=",
"{",
"'n'",
":",
"namespace",
"}",
"controls_list",
"=",
"root",
".",
"xpath",
"(",
"'n:controls'",
",",
"namespaces",
"=",
"namespaces",
")",
"if",
"co... | get controls from coordinator xml set properties on coordinator with controls from xml etree root . | train | false |
53,267 | def loaded_module_info(module_name):
l_raw = utils.system_output('/sbin/lsmod')
return parse_lsmod_for_module(l_raw, module_name)
| [
"def",
"loaded_module_info",
"(",
"module_name",
")",
":",
"l_raw",
"=",
"utils",
".",
"system_output",
"(",
"'/sbin/lsmod'",
")",
"return",
"parse_lsmod_for_module",
"(",
"l_raw",
",",
"module_name",
")"
] | get loaded module details: size and submodules . | train | false |
53,268 | def test_keyword():
defs = Script('print').goto_definitions()
if is_py3:
assert [d.doc for d in defs]
else:
assert (defs == [])
assert (Script('import').goto_assignments() == [])
completions = Script('import', 1, 1).completions()
assert ((len(completions) > 10) and ('if' in [c.name for c in completions]))
assert (Script('assert').goto_definitions() == [])
| [
"def",
"test_keyword",
"(",
")",
":",
"defs",
"=",
"Script",
"(",
"'print'",
")",
".",
"goto_definitions",
"(",
")",
"if",
"is_py3",
":",
"assert",
"[",
"d",
".",
"doc",
"for",
"d",
"in",
"defs",
"]",
"else",
":",
"assert",
"(",
"defs",
"==",
"[",
... | github jedi-vim issue #44 . | train | false |
53,269 | def _get_sequence_list():
from django.db import models
apps = models.get_apps()
sequence_list = []
for app in apps:
for model in models.get_models(app):
for f in model._meta.fields:
if isinstance(f, models.AutoField):
sequence_list.append({'table': model._meta.db_table, 'column': f.column})
break
for f in model._meta.many_to_many:
sequence_list.append({'table': f.m2m_db_table(), 'column': None})
return sequence_list
| [
"def",
"_get_sequence_list",
"(",
")",
":",
"from",
"django",
".",
"db",
"import",
"models",
"apps",
"=",
"models",
".",
"get_apps",
"(",
")",
"sequence_list",
"=",
"[",
"]",
"for",
"app",
"in",
"apps",
":",
"for",
"model",
"in",
"models",
".",
"get_mo... | returns a list of information about all db sequences for all models in all apps . | train | false |
53,270 | def _format_slug_for_request(slug):
index = slug.find(TEMPLATE_TITLE_PREFIX)
if (index != (-1)):
slug = ('%s%s' % (TEMPLATE_TITLE_PREFIX, slug[(index + len(TEMPLATE_TITLE_PREFIX)):].lower()))
return slug
| [
"def",
"_format_slug_for_request",
"(",
"slug",
")",
":",
"index",
"=",
"slug",
".",
"find",
"(",
"TEMPLATE_TITLE_PREFIX",
")",
"if",
"(",
"index",
"!=",
"(",
"-",
"1",
")",
")",
":",
"slug",
"=",
"(",
"'%s%s'",
"%",
"(",
"TEMPLATE_TITLE_PREFIX",
",",
... | formats a document slug which will play nice with kumascript caching . | train | false |
53,271 | def sdm_deg(f):
return max((sdm_monomial_deg(M[0]) for M in f))
| [
"def",
"sdm_deg",
"(",
"f",
")",
":",
"return",
"max",
"(",
"(",
"sdm_monomial_deg",
"(",
"M",
"[",
"0",
"]",
")",
"for",
"M",
"in",
"f",
")",
")"
] | degree of f . | train | false |
53,274 | def _ssh_read_next_mpint(data):
(mpint_data, rest) = _ssh_read_next_string(data)
return (utils.int_from_bytes(mpint_data, byteorder='big', signed=False), rest)
| [
"def",
"_ssh_read_next_mpint",
"(",
"data",
")",
":",
"(",
"mpint_data",
",",
"rest",
")",
"=",
"_ssh_read_next_string",
"(",
"data",
")",
"return",
"(",
"utils",
".",
"int_from_bytes",
"(",
"mpint_data",
",",
"byteorder",
"=",
"'big'",
",",
"signed",
"=",
... | reads the next mpint from the data . | train | false |
53,276 | def getdraw(im=None, hints=None):
handler = None
if ((not hints) or ('nicest' in hints)):
try:
from . import _imagingagg as handler
except ImportError:
pass
if (handler is None):
from . import ImageDraw2 as handler
if im:
im = handler.Draw(im)
return (im, handler)
| [
"def",
"getdraw",
"(",
"im",
"=",
"None",
",",
"hints",
"=",
"None",
")",
":",
"handler",
"=",
"None",
"if",
"(",
"(",
"not",
"hints",
")",
"or",
"(",
"'nicest'",
"in",
"hints",
")",
")",
":",
"try",
":",
"from",
".",
"import",
"_imagingagg",
"as... | a more advanced 2d drawing interface for pil images . | train | false |
53,277 | def fix_arg(arg):
if isinstance(arg, str):
arg = _intrinsics.InvokeCommand.ExpandString(arg)
elif isinstance(arg, PSObjectWrapper):
arg = arg.data
elif isinstance(arg, ShellOutput):
arg = arg.data
return arg
| [
"def",
"fix_arg",
"(",
"arg",
")",
":",
"if",
"isinstance",
"(",
"arg",
",",
"str",
")",
":",
"arg",
"=",
"_intrinsics",
".",
"InvokeCommand",
".",
"ExpandString",
"(",
"arg",
")",
"elif",
"isinstance",
"(",
"arg",
",",
"PSObjectWrapper",
")",
":",
"ar... | utility function converts arg to type string . | train | false |
53,278 | def payload_from_raw(raw, linktype=1):
ip = iplayer_from_raw(raw, linktype)
try:
return ip.data.data
except:
return ''
| [
"def",
"payload_from_raw",
"(",
"raw",
",",
"linktype",
"=",
"1",
")",
":",
"ip",
"=",
"iplayer_from_raw",
"(",
"raw",
",",
"linktype",
")",
"try",
":",
"return",
"ip",
".",
"data",
".",
"data",
"except",
":",
"return",
"''"
] | get the payload from a packet . | train | false |
53,279 | def _turtle_docrevise(docstr):
import re
if (docstr is None):
return None
turtlename = _CFG['exampleturtle']
newdocstr = docstr.replace(('%s.' % turtlename), '')
parexp = re.compile((' \\(.+ %s\\):' % turtlename))
newdocstr = parexp.sub(':', newdocstr)
return newdocstr
| [
"def",
"_turtle_docrevise",
"(",
"docstr",
")",
":",
"import",
"re",
"if",
"(",
"docstr",
"is",
"None",
")",
":",
"return",
"None",
"turtlename",
"=",
"_CFG",
"[",
"'exampleturtle'",
"]",
"newdocstr",
"=",
"docstr",
".",
"replace",
"(",
"(",
"'%s.'",
"%"... | to reduce docstrings from rawturtle class for functions . | train | false |
53,280 | def EventHandler(source_restriction=False, auth_required=True, allow_client_access=False):
def Decorator(f):
'Initialised Decorator.'
@functools.wraps(f)
def Decorated(self, msg):
'A decorator that assists in enforcing EventListener restrictions.'
if (auth_required and (msg.auth_state != msg.AuthorizationState.AUTHENTICATED)):
raise RuntimeError(('Message from %s not authenticated.' % msg.source))
if ((not allow_client_access) and msg.source and rdf_client.ClientURN.Validate(msg.source)):
raise RuntimeError('Event does not support clients.')
if source_restriction:
source_check_method = getattr(self, 'CheckSource')
if (not source_check_method):
raise RuntimeError('CheckSource method not found.')
if (not source_check_method(msg.source)):
raise RuntimeError('Message source invalid.')
stats.STATS.IncrementCounter('grr_worker_states_run')
rdf_msg = rdf_flows.GrrMessage(msg)
res = f(self, message=rdf_msg, event=rdf_msg.payload)
return res
return Decorated
return Decorator
| [
"def",
"EventHandler",
"(",
"source_restriction",
"=",
"False",
",",
"auth_required",
"=",
"True",
",",
"allow_client_access",
"=",
"False",
")",
":",
"def",
"Decorator",
"(",
"f",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"f",
")",
"def",
"Decorated"... | a convenience decorator for event handlers . | train | false |
53,281 | def _index_to_ticklabels(index):
if isinstance(index, pd.MultiIndex):
return ['-'.join(map(str, i)) for i in index.values]
else:
return index.values
| [
"def",
"_index_to_ticklabels",
"(",
"index",
")",
":",
"if",
"isinstance",
"(",
"index",
",",
"pd",
".",
"MultiIndex",
")",
":",
"return",
"[",
"'-'",
".",
"join",
"(",
"map",
"(",
"str",
",",
"i",
")",
")",
"for",
"i",
"in",
"index",
".",
"values"... | convert a pandas index or multiindex into ticklabels . | train | false |
53,282 | def filter_pad(val, width, fillchar=u'0'):
return str(val).rjust(width, fillchar)
| [
"def",
"filter_pad",
"(",
"val",
",",
"width",
",",
"fillchar",
"=",
"u'0'",
")",
":",
"return",
"str",
"(",
"val",
")",
".",
"rjust",
"(",
"width",
",",
"fillchar",
")"
] | pads a number or string with fillchar to the specified width . | train | false |
53,283 | def test_dispatch():
gotoutput = pretty.pretty(MyDict())
expectedoutput = 'MyDict(...)'
nt.assert_equal(gotoutput, expectedoutput)
| [
"def",
"test_dispatch",
"(",
")",
":",
"gotoutput",
"=",
"pretty",
".",
"pretty",
"(",
"MyDict",
"(",
")",
")",
"expectedoutput",
"=",
"'MyDict(...)'",
"nt",
".",
"assert_equal",
"(",
"gotoutput",
",",
"expectedoutput",
")"
] | test correct dispatching: the _repr_pretty_ method for mydict must be found before the registered printer for dict . | train | false |
53,284 | def path_as_windows(fpath):
winepath = ('C:\\' + fpath.split('drive_c')[1])
return winepath
| [
"def",
"path_as_windows",
"(",
"fpath",
")",
":",
"winepath",
"=",
"(",
"'C:\\\\'",
"+",
"fpath",
".",
"split",
"(",
"'drive_c'",
")",
"[",
"1",
"]",
")",
"return",
"winepath"
] | return the file path as wine expects . | train | false |
53,285 | def _determine_default_project(project=None):
if (project is None):
(_, project) = google.auth.default()
return project
| [
"def",
"_determine_default_project",
"(",
"project",
"=",
"None",
")",
":",
"if",
"(",
"project",
"is",
"None",
")",
":",
"(",
"_",
",",
"project",
")",
"=",
"google",
".",
"auth",
".",
"default",
"(",
")",
"return",
"project"
] | determine default project id explicitly or implicitly as fall-back . | train | false |
53,286 | def squish(text):
return re.sub('\\s+', ' ', text)
| [
"def",
"squish",
"(",
"text",
")",
":",
"return",
"re",
".",
"sub",
"(",
"'\\\\s+'",
",",
"' '",
",",
"text",
")"
] | turn any run of whitespace into one space . | train | false |
53,288 | def kill(coro):
return KillEvent(coro)
| [
"def",
"kill",
"(",
"coro",
")",
":",
"return",
"KillEvent",
"(",
"coro",
")"
] | halt the execution of a different spawned thread . | train | false |
53,290 | def _serialize_range(start, end):
if (start < 0):
range_str = ('%d' % start)
elif (end is None):
range_str = ('%d-' % start)
else:
range_str = ('%d-%d' % (start, end))
return ('bytes=%s' % range_str)
| [
"def",
"_serialize_range",
"(",
"start",
",",
"end",
")",
":",
"if",
"(",
"start",
"<",
"0",
")",
":",
"range_str",
"=",
"(",
"'%d'",
"%",
"start",
")",
"elif",
"(",
"end",
"is",
"None",
")",
":",
"range_str",
"=",
"(",
"'%d-'",
"%",
"start",
")"... | return a string suitable for use as a value in a range header . | train | false |
53,292 | def ftp(registry, xml_parent, data):
console_prefix = 'FTP: '
plugin_tag = 'jenkins.plugins.publish__over__ftp.BapFtpPublisherPlugin'
publisher_tag = 'jenkins.plugins.publish__over__ftp.BapFtpPublisher'
transfer_tag = 'jenkins.plugins.publish__over__ftp.BapFtpTransfer'
plugin_reference_tag = 'jenkins.plugins.publish_over_ftp.BapFtpPublisherPlugin'
(_, transfer_node) = base_publish_over(xml_parent, data, console_prefix, plugin_tag, publisher_tag, transfer_tag, plugin_reference_tag)
XML.SubElement(transfer_node, 'asciiMode').text = 'false'
| [
"def",
"ftp",
"(",
"registry",
",",
"xml_parent",
",",
"data",
")",
":",
"console_prefix",
"=",
"'FTP: '",
"plugin_tag",
"=",
"'jenkins.plugins.publish__over__ftp.BapFtpPublisherPlugin'",
"publisher_tag",
"=",
"'jenkins.plugins.publish__over__ftp.BapFtpPublisher'",
"transfer_ta... | yaml: ftp upload files via ftp . | train | false |
53,293 | def _worker_ctl(worker, lbn, vwa, profile='default'):
cmd = {'cmd': 'update', 'mime': 'prop', 'w': lbn, 'sw': worker, 'vwa': vwa}
return (_do_http(cmd, profile)['worker.result.type'] == 'OK')
| [
"def",
"_worker_ctl",
"(",
"worker",
",",
"lbn",
",",
"vwa",
",",
"profile",
"=",
"'default'",
")",
":",
"cmd",
"=",
"{",
"'cmd'",
":",
"'update'",
",",
"'mime'",
":",
"'prop'",
",",
"'w'",
":",
"lbn",
",",
"'sw'",
":",
"worker",
",",
"'vwa'",
":",... | enable/disable/stop a worker . | train | true |
53,295 | def find_readline_lib():
import readline
f = open(readline.__file__, 'rb')
try:
data = f.read()
finally:
f.close()
import re
m = re.search('\x00([^\x00]*libreadline[^\x00]*)\x00', data)
if m:
return m.group(1)
return None
| [
"def",
"find_readline_lib",
"(",
")",
":",
"import",
"readline",
"f",
"=",
"open",
"(",
"readline",
".",
"__file__",
",",
"'rb'",
")",
"try",
":",
"data",
"=",
"f",
".",
"read",
"(",
")",
"finally",
":",
"f",
".",
"close",
"(",
")",
"import",
"re",... | return the name of the readline library linked to the given readline module . | train | false |
53,297 | def integrate_hypertangent_polynomial(p, DE):
(q, r) = polynomial_reduce(p, DE)
a = DE.d.exquo(Poly(((DE.t ** 2) + 1), DE.t))
c = Poly((r.nth(1) / (2 * a.as_expr())), DE.t)
return (q, c)
| [
"def",
"integrate_hypertangent_polynomial",
"(",
"p",
",",
"DE",
")",
":",
"(",
"q",
",",
"r",
")",
"=",
"polynomial_reduce",
"(",
"p",
",",
"DE",
")",
"a",
"=",
"DE",
".",
"d",
".",
"exquo",
"(",
"Poly",
"(",
"(",
"(",
"DE",
".",
"t",
"**",
"2... | integration of hypertangent polynomials . | train | false |
53,298 | def _wait_for_status(linode_id, status=None, timeout=300, quiet=True):
if (status is None):
status = _get_status_id_by_name('brand_new')
status_desc_waiting = _get_status_descr_by_id(status)
interval = 5
iterations = int((timeout / interval))
for i in range(0, iterations):
result = get_linode(kwargs={'linode_id': linode_id})
if (result['STATUS'] == status):
return True
status_desc_result = _get_status_descr_by_id(result['STATUS'])
time.sleep(interval)
if quiet:
log.info("Status for Linode {0} is '{1}', waiting for '{2}'.".format(linode_id, status_desc_result, status_desc_waiting))
else:
log.debug("Status for Linode {0} is '{1}', waiting for '{2}'.".format(linode_id, status_desc_result, status_desc_waiting))
return False
| [
"def",
"_wait_for_status",
"(",
"linode_id",
",",
"status",
"=",
"None",
",",
"timeout",
"=",
"300",
",",
"quiet",
"=",
"True",
")",
":",
"if",
"(",
"status",
"is",
"None",
")",
":",
"status",
"=",
"_get_status_id_by_name",
"(",
"'brand_new'",
")",
"stat... | wait for a certain status from linode . | train | false |
53,300 | def uri_param(event_name, param, value, **kwargs):
cli_argument = param
qualified_param_name = '.'.join(event_name.split('.')[1:])
if ((qualified_param_name in PARAMFILE_DISABLED) or getattr(cli_argument, 'no_paramfile', None)):
return
else:
return _check_for_uri_param(cli_argument, value)
| [
"def",
"uri_param",
"(",
"event_name",
",",
"param",
",",
"value",
",",
"**",
"kwargs",
")",
":",
"cli_argument",
"=",
"param",
"qualified_param_name",
"=",
"'.'",
".",
"join",
"(",
"event_name",
".",
"split",
"(",
"'.'",
")",
"[",
"1",
":",
"]",
")",
... | handler that supports param values from uris . | train | false |
53,301 | @shared_task(bind=True, base=DebugBasketTask, default_retry_delay=BASKET_TASK_RETRY_DELAY, max_retries=BASKET_TASK_MAX_RETRIES)
def unsubscribe_user_task(self, result, newsletters=[], optout=False):
if (not result):
return None
newsletters_to_unsubscribe = []
if (result.get('status') == 'ok'):
email = result.get('email')
token = result.get('token')
if newsletters:
newsletters_to_unsubscribe = list(set(newsletters).intersection(result['newsletters']))
else:
newsletters_to_unsubscribe = list(set(MOZILLIANS_NEWSLETTERS).intersection(result['newsletters']))
if newsletters_to_unsubscribe:
try:
unsubscribe_result = basket.unsubscribe(token=token, email=email, newsletters=newsletters_to_unsubscribe, optout=optout)
except MaxRetriesExceededError as exc:
raise exc
except basket.BasketException as exc:
raise self.retry(exc=exc)
return unsubscribe_result
return None
| [
"@",
"shared_task",
"(",
"bind",
"=",
"True",
",",
"base",
"=",
"DebugBasketTask",
",",
"default_retry_delay",
"=",
"BASKET_TASK_RETRY_DELAY",
",",
"max_retries",
"=",
"BASKET_TASK_MAX_RETRIES",
")",
"def",
"unsubscribe_user_task",
"(",
"self",
",",
"result",
",",
... | removes a user from the basket subscription . | train | false |
53,302 | def oauth_url(client_id, permissions=None, server=None, redirect_uri=None):
url = 'https://discordapp.com/oauth2/authorize?client_id={}&scope=bot'.format(client_id)
if (permissions is not None):
url = ((url + '&permissions=') + str(permissions.value))
if (server is not None):
url = ((url + '&guild_id=') + server.id)
if (redirect_uri is not None):
from urllib.parse import urlencode
url = ((url + '&response_type=code&') + urlencode({'redirect_uri': redirect_uri}))
return url
| [
"def",
"oauth_url",
"(",
"client_id",
",",
"permissions",
"=",
"None",
",",
"server",
"=",
"None",
",",
"redirect_uri",
"=",
"None",
")",
":",
"url",
"=",
"'https://discordapp.com/oauth2/authorize?client_id={}&scope=bot'",
".",
"format",
"(",
"client_id",
")",
"if... | a helper function that returns the oauth2 url for inviting the bot into servers . | train | true |
53,303 | def event(name, priority=128):
def decorator(func):
add_event_handler(name, func, priority)
return func
return decorator
| [
"def",
"event",
"(",
"name",
",",
"priority",
"=",
"128",
")",
":",
"def",
"decorator",
"(",
"func",
")",
":",
"add_event_handler",
"(",
"name",
",",
"func",
",",
"priority",
")",
"return",
"func",
"return",
"decorator"
] | watch salts event bus and block until the given tag is matched . | train | false |
53,304 | def is_string(obj):
try:
return isinstance(obj, basestring)
except NameError:
return isinstance(obj, str)
| [
"def",
"is_string",
"(",
"obj",
")",
":",
"try",
":",
"return",
"isinstance",
"(",
"obj",
",",
"basestring",
")",
"except",
"NameError",
":",
"return",
"isinstance",
"(",
"obj",
",",
"str",
")"
] | returns true if s is string or string-like object . | train | false |
53,307 | def file_requires_unicode(x):
try:
x.write('')
except TypeError:
return True
else:
return False
| [
"def",
"file_requires_unicode",
"(",
"x",
")",
":",
"try",
":",
"x",
".",
"write",
"(",
"''",
")",
"except",
"TypeError",
":",
"return",
"True",
"else",
":",
"return",
"False"
] | returns true if the given writable file-like object requires unicode to be written to it . | train | false |
53,308 | def _build_args(method, ip, comment):
opt = _get_opt(method)
args = '{0} {1}'.format(opt, ip)
if comment:
args += ' {0}'.format(comment)
return args
| [
"def",
"_build_args",
"(",
"method",
",",
"ip",
",",
"comment",
")",
":",
"opt",
"=",
"_get_opt",
"(",
"method",
")",
"args",
"=",
"'{0} {1}'",
".",
"format",
"(",
"opt",
",",
"ip",
")",
"if",
"comment",
":",
"args",
"+=",
"' {0}'",
".",
"format",
... | returns the cmd args for csf basic allow/deny commands . | train | true |
53,309 | def _inherit_from(context, uri, calling_uri):
if (uri is None):
return None
template = _lookup_template(context, uri, calling_uri)
self_ns = context['self']
ih = self_ns
while (ih.inherits is not None):
ih = ih.inherits
lclcontext = context._locals({'next': ih})
ih.inherits = TemplateNamespace(('self:%s' % template.uri), lclcontext, template=template, populate_self=False)
context._data['parent'] = lclcontext._data['local'] = ih.inherits
callable_ = getattr(template.module, '_mako_inherit', None)
if (callable_ is not None):
ret = callable_(template, lclcontext)
if ret:
return ret
gen_ns = getattr(template.module, '_mako_generate_namespaces', None)
if (gen_ns is not None):
gen_ns(context)
return (template.callable_, lclcontext)
| [
"def",
"_inherit_from",
"(",
"context",
",",
"uri",
",",
"calling_uri",
")",
":",
"if",
"(",
"uri",
"is",
"None",
")",
":",
"return",
"None",
"template",
"=",
"_lookup_template",
"(",
"context",
",",
"uri",
",",
"calling_uri",
")",
"self_ns",
"=",
"conte... | called by the _inherit method in template modules to set up the inheritance chain at the start of a templates execution . | train | true |
53,310 | def clean_opf(container):
manifest_id_map = container.manifest_id_map
for meta in container.opf_xpath(u'//opf:meta[@name="cover" and @content]'):
name = manifest_id_map.get(meta.get(u'content', None), None)
container.remove_from_xml(meta)
if (name and (name in container.name_path_map)):
(yield name)
gtm = container.guide_type_map
for ref in container.opf_xpath(u'//opf:guide/opf:reference[@type]'):
typ = ref.get(u'type', u'')
if (typ.lower() in COVER_TYPES):
container.remove_from_xml(ref)
name = gtm.get(typ, None)
if (name and (name in container.name_path_map)):
(yield name)
removed_names = container.apply_unique_properties(None, u'cover-image', u'calibre:title-page')[0]
for name in removed_names:
(yield name)
container.dirty(container.opf_name)
| [
"def",
"clean_opf",
"(",
"container",
")",
":",
"manifest_id_map",
"=",
"container",
".",
"manifest_id_map",
"for",
"meta",
"in",
"container",
".",
"opf_xpath",
"(",
"u'//opf:meta[@name=\"cover\" and @content]'",
")",
":",
"name",
"=",
"manifest_id_map",
".",
"get",... | remove all references to covers from the opf . | train | false |
53,311 | def saltversion():
from salt.version import __version__
return {'saltversion': __version__}
| [
"def",
"saltversion",
"(",
")",
":",
"from",
"salt",
".",
"version",
"import",
"__version__",
"return",
"{",
"'saltversion'",
":",
"__version__",
"}"
] | return the version of salt . | train | false |
53,312 | def _check_filter_and_make_params(entity, includes, release_status=[], release_type=[]):
if isinstance(release_status, compat.basestring):
release_status = [release_status]
if isinstance(release_type, compat.basestring):
release_type = [release_type]
_check_filter(release_status, VALID_RELEASE_STATUSES)
_check_filter(release_type, VALID_RELEASE_TYPES)
if (release_status and ('releases' not in includes) and (entity != 'release')):
raise InvalidFilterError("Can't have a status with no release include")
if (release_type and ('release-groups' not in includes) and ('releases' not in includes) and (entity not in ['release-group', 'release'])):
raise InvalidFilterError("Can't have a release type with no releases or release-groups involved")
params = {}
if len(release_status):
params['status'] = '|'.join(release_status)
if len(release_type):
params['type'] = '|'.join(release_type)
return params
| [
"def",
"_check_filter_and_make_params",
"(",
"entity",
",",
"includes",
",",
"release_status",
"=",
"[",
"]",
",",
"release_type",
"=",
"[",
"]",
")",
":",
"if",
"isinstance",
"(",
"release_status",
",",
"compat",
".",
"basestring",
")",
":",
"release_status",... | check that the status or type values are valid . | train | false |
53,314 | def raisehttp():
raise HTTP(400, 'internal error')
| [
"def",
"raisehttp",
"(",
")",
":",
"raise",
"HTTP",
"(",
"400",
",",
"'internal error'",
")"
] | returns an http 400 error page . | train | false |
53,316 | @_ConfigurableFilter(executable='HTML_TIDY_EXECUTABLE')
def html_tidy_wrap(infile, executable='tidy5'):
return _html_tidy_runner(infile, '-quiet --show-info no --show-warnings no -utf8 -indent --indent-attributes no --sort-attributes alpha --wrap 80 --wrap-sections no --drop-empty-elements no --tidy-mark no -modify %1', executable=executable)
| [
"@",
"_ConfigurableFilter",
"(",
"executable",
"=",
"'HTML_TIDY_EXECUTABLE'",
")",
"def",
"html_tidy_wrap",
"(",
"infile",
",",
"executable",
"=",
"'tidy5'",
")",
":",
"return",
"_html_tidy_runner",
"(",
"infile",
",",
"'-quiet --show-info no --show-warnings no -utf8 -ind... | run html tidy with line wrapping . | train | false |
53,318 | def pearson_correlation(X, Y):
if (X is Y):
X = Y = np.asanyarray(X)
else:
X = np.asanyarray(X)
Y = np.asanyarray(Y)
if (X.shape[1] != Y.shape[1]):
raise ValueError('Incompatible dimension for X and Y matrices')
XY = ssd.cdist(X, Y, 'correlation', 2)
return (1 - XY)
| [
"def",
"pearson_correlation",
"(",
"X",
",",
"Y",
")",
":",
"if",
"(",
"X",
"is",
"Y",
")",
":",
"X",
"=",
"Y",
"=",
"np",
".",
"asanyarray",
"(",
"X",
")",
"else",
":",
"X",
"=",
"np",
".",
"asanyarray",
"(",
"X",
")",
"Y",
"=",
"np",
".",... | considering the rows of x as vectors . | train | false |
53,319 | def _GetLargePdbShimCcPath():
this_dir = os.path.abspath(os.path.dirname(__file__))
src_dir = os.path.abspath(os.path.join(this_dir, '..', '..'))
win_data_dir = os.path.join(src_dir, 'data', 'win')
large_pdb_shim_cc = os.path.join(win_data_dir, 'large-pdb-shim.cc')
return large_pdb_shim_cc
| [
"def",
"_GetLargePdbShimCcPath",
"(",
")",
":",
"this_dir",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
")",
"src_dir",
"=",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"... | returns the path of the large_pdb_shim . | train | false |
53,320 | def get_mask_ipv6(bits):
if ((bits > 128) or (bits < 0)):
raise ValueError(('A mask can only be 0-128 bits, got %i' % bits))
elif (bits == 128):
return FULL_IPv6_MASK
mask_bin = _get_binary(((2 ** bits) - 1), 128)[::(-1)]
groupings = [mask_bin[(16 * i):(16 * (i + 1))] for i in range(8)]
return ':'.join([('%04x' % int(group, 2)) for group in groupings]).upper()
| [
"def",
"get_mask_ipv6",
"(",
"bits",
")",
":",
"if",
"(",
"(",
"bits",
">",
"128",
")",
"or",
"(",
"bits",
"<",
"0",
")",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'A mask can only be 0-128 bits, got %i'",
"%",
"bits",
")",
")",
"elif",
"(",
"bits",
... | provides the ipv6 mask for a given number of bits . | train | false |
53,321 | def _norm_encoding(encoding):
try:
return codecs.lookup(encoding).name
except LookupError:
return encoding
| [
"def",
"_norm_encoding",
"(",
"encoding",
")",
":",
"try",
":",
"return",
"codecs",
".",
"lookup",
"(",
"encoding",
")",
".",
"name",
"except",
"LookupError",
":",
"return",
"encoding"
] | normalize the encoding name -- where "normalized" is what pythons codecs module calls it . | train | false |
53,322 | def is_stopped():
return (status() == 'stopped')
| [
"def",
"is_stopped",
"(",
")",
":",
"return",
"(",
"status",
"(",
")",
"==",
"'stopped'",
")"
] | check if the firewall is stopped . | train | false |
53,323 | def cluster_exists(version, name='main'):
return ('{0}/{1}'.format(version, name) in cluster_list())
| [
"def",
"cluster_exists",
"(",
"version",
",",
"name",
"=",
"'main'",
")",
":",
"return",
"(",
"'{0}/{1}'",
".",
"format",
"(",
"version",
",",
"name",
")",
"in",
"cluster_list",
"(",
")",
")"
] | checks if a given version and name of a cluster exists . | train | false |
53,324 | def write_drawing(worksheet):
if (worksheet._charts or worksheet._images):
rel = Relationship(type='drawing', target='')
worksheet._rels.append(rel)
drawing = Related()
drawing.id = ('rId%s' % len(worksheet._rels))
return drawing.to_tree('drawing')
| [
"def",
"write_drawing",
"(",
"worksheet",
")",
":",
"if",
"(",
"worksheet",
".",
"_charts",
"or",
"worksheet",
".",
"_images",
")",
":",
"rel",
"=",
"Relationship",
"(",
"type",
"=",
"'drawing'",
",",
"target",
"=",
"''",
")",
"worksheet",
".",
"_rels",
... | add link to drawing if required . | train | false |
53,325 | def mdft(n):
mat = [[None for x in range(n)] for y in range(n)]
base = exp(((((-2) * pi) * I) / n))
mat[0] = ([1] * n)
for i in range(n):
mat[i][0] = 1
for i in range(1, n):
for j in range(i, n):
mat[i][j] = mat[j][i] = (base ** (i * j))
return ((1 / sqrt(n)) * Matrix(mat))
| [
"def",
"mdft",
"(",
"n",
")",
":",
"mat",
"=",
"[",
"[",
"None",
"for",
"x",
"in",
"range",
"(",
"n",
")",
"]",
"for",
"y",
"in",
"range",
"(",
"n",
")",
"]",
"base",
"=",
"exp",
"(",
"(",
"(",
"(",
"(",
"-",
"2",
")",
"*",
"pi",
")",
... | returns an expression of a discrete fourier transform as a matrix multiplication . | train | false |
53,326 | @pytest.mark.xfail('not HAS_BZ2')
def test_guessing_file_object():
t = ascii.read(open('t/ipac.dat.bz2', 'rb'))
assert (t.colnames == ['ra', 'dec', 'sai', 'v2', 'sptype'])
| [
"@",
"pytest",
".",
"mark",
".",
"xfail",
"(",
"'not HAS_BZ2'",
")",
"def",
"test_guessing_file_object",
"(",
")",
":",
"t",
"=",
"ascii",
".",
"read",
"(",
"open",
"(",
"'t/ipac.dat.bz2'",
",",
"'rb'",
")",
")",
"assert",
"(",
"t",
".",
"colnames",
"=... | test guessing a file object . | train | false |
53,327 | def _pretty_fulltext_sentence(sent):
outstr = u''
outstr += u'full-text sentence ({0.ID}) in {1}:\n\n'.format(sent, sent.doc.get(u'name', sent.doc.description))
outstr += u'\n[POS] {0} tags\n'.format(len(sent.POS))
outstr += u'\n[POS_tagset] {0}\n\n'.format(sent.POS_tagset)
outstr += u'[text] + [annotationSet]\n\n'
outstr += sent._ascii()
outstr += u'\n'
return outstr
| [
"def",
"_pretty_fulltext_sentence",
"(",
"sent",
")",
":",
"outstr",
"=",
"u''",
"outstr",
"+=",
"u'full-text sentence ({0.ID}) in {1}:\\n\\n'",
".",
"format",
"(",
"sent",
",",
"sent",
".",
"doc",
".",
"get",
"(",
"u'name'",
",",
"sent",
".",
"doc",
".",
"d... | helper function for pretty-printing an annotated sentence from a full-text document . | train | false |
53,328 | def _fixup_cdef_enums(string, reg=re.compile('=\\s*(\\d+)\\s*<<\\s*(\\d+)')):
def repl_shift(match):
shift_by = int(match.group(2))
value = int(match.group(1))
int_value = ctypes.c_int((value << shift_by)).value
return ('= %s' % str(int_value))
return reg.sub(repl_shift, string)
| [
"def",
"_fixup_cdef_enums",
"(",
"string",
",",
"reg",
"=",
"re",
".",
"compile",
"(",
"'=\\\\s*(\\\\d+)\\\\s*<<\\\\s*(\\\\d+)'",
")",
")",
":",
"def",
"repl_shift",
"(",
"match",
")",
":",
"shift_by",
"=",
"int",
"(",
"match",
".",
"group",
"(",
"2",
")",... | converts some common enum expressions to constants . | train | true |
53,330 | def test_no_dot():
line = Line()
line.add('no dot', [])
q = line.render_pyquery()
assert (q('.text-overlay text').text() == 'No data')
| [
"def",
"test_no_dot",
"(",
")",
":",
"line",
"=",
"Line",
"(",
")",
"line",
".",
"add",
"(",
"'no dot'",
",",
"[",
"]",
")",
"q",
"=",
"line",
".",
"render_pyquery",
"(",
")",
"assert",
"(",
"q",
"(",
"'.text-overlay text'",
")",
".",
"text",
"(",
... | line test with an empty serie . | train | false |
53,331 | @handle_dashboard_error
@require_POST
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
@require_level('staff')
@require_post_params('url')
def show_unit_extensions(request, course_id):
course = get_course_by_id(SlashSeparatedCourseKey.from_deprecated_string(course_id))
unit = find_unit(course, request.POST.get('url'))
return JsonResponse(dump_module_extensions(course, unit))
| [
"@",
"handle_dashboard_error",
"@",
"require_POST",
"@",
"ensure_csrf_cookie",
"@",
"cache_control",
"(",
"no_cache",
"=",
"True",
",",
"no_store",
"=",
"True",
",",
"must_revalidate",
"=",
"True",
")",
"@",
"require_level",
"(",
"'staff'",
")",
"@",
"require_po... | shows all of the students which have due date extensions for the given unit . | train | false |
53,332 | def get_preferred_file_name_encoding():
return (sys.getfilesystemencoding() or locale.getpreferredencoding() or u'utf-8')
| [
"def",
"get_preferred_file_name_encoding",
"(",
")",
":",
"return",
"(",
"sys",
".",
"getfilesystemencoding",
"(",
")",
"or",
"locale",
".",
"getpreferredencoding",
"(",
")",
"or",
"u'utf-8'",
")"
] | get preferred file name encoding . | train | false |
53,333 | def cleanup_sys_modules(directories):
cleaned = []
for (modname, module) in list(sys.modules.items()):
modfile = getattr(module, '__file__', None)
if modfile:
for directory in directories:
if modfile.startswith(directory):
cleaned.append(modname)
del sys.modules[modname]
break
return cleaned
| [
"def",
"cleanup_sys_modules",
"(",
"directories",
")",
":",
"cleaned",
"=",
"[",
"]",
"for",
"(",
"modname",
",",
"module",
")",
"in",
"list",
"(",
"sys",
".",
"modules",
".",
"items",
"(",
")",
")",
":",
"modfile",
"=",
"getattr",
"(",
"module",
","... | remove submodules of directories from sys . | train | false |
53,334 | def check_cli(module, cli):
vrouter_name = module.params['pn_vrouter_name']
interface_ip = module.params['pn_interface_ip']
global VROUTER_EXISTS, LB_INTERFACE_EXISTS
check_vrouter = (cli + ' vrouter-show format name no-show-headers ')
check_vrouter = shlex.split(check_vrouter)
out = module.run_command(check_vrouter)[1]
out = out.split()
if (vrouter_name in out):
VROUTER_EXISTS = True
else:
VROUTER_EXISTS = False
show = (cli + (' vrouter-loopback-interface-show vrouter-name %s format ip no-show-headers' % vrouter_name))
show = shlex.split(show)
out = module.run_command(show)[1]
out = out.split()
if (interface_ip in out):
LB_INTERFACE_EXISTS = True
else:
LB_INTERFACE_EXISTS = False
| [
"def",
"check_cli",
"(",
"module",
",",
"cli",
")",
":",
"vrouter_name",
"=",
"module",
".",
"params",
"[",
"'pn_vrouter_name'",
"]",
"interface_ip",
"=",
"module",
".",
"params",
"[",
"'pn_interface_ip'",
"]",
"global",
"VROUTER_EXISTS",
",",
"LB_INTERFACE_EXIS... | this method checks if vrouter exists on the target node . | train | false |
53,335 | def get_soap_accessor():
db_ip = appscale_info.get_db_master_ip()
bindport = constants.UA_SERVER_PORT
return SOAPpy.SOAPProxy('https://{0}:{1}'.format(db_ip, bindport))
| [
"def",
"get_soap_accessor",
"(",
")",
":",
"db_ip",
"=",
"appscale_info",
".",
"get_db_master_ip",
"(",
")",
"bindport",
"=",
"constants",
".",
"UA_SERVER_PORT",
"return",
"SOAPpy",
".",
"SOAPProxy",
"(",
"'https://{0}:{1}'",
".",
"format",
"(",
"db_ip",
",",
... | returns the soap server accessor to deal with application and users . | train | false |
53,336 | def relative_path(filename, start=os.path.curdir):
try:
(dirname, basename) = os.path.split(filename)
relative_dir = os.path.relpath(dirname, start)
return os.path.join(relative_dir, basename)
except ValueError:
return os.path.abspath(filename)
| [
"def",
"relative_path",
"(",
"filename",
",",
"start",
"=",
"os",
".",
"path",
".",
"curdir",
")",
":",
"try",
":",
"(",
"dirname",
",",
"basename",
")",
"=",
"os",
".",
"path",
".",
"split",
"(",
"filename",
")",
"relative_dir",
"=",
"os",
".",
"p... | cross platform relative path of a filename . | train | false |
53,337 | @click.command(u'show-pending-jobs')
@click.option(u'--site', help=u'site name')
@pass_context
def show_pending_jobs(context, site=None):
from frappe.utils.doctor import pending_jobs as _pending_jobs
if (not site):
site = get_site(context)
with frappe.init_site(site):
pending_jobs = _pending_jobs(site=site)
return pending_jobs
| [
"@",
"click",
".",
"command",
"(",
"u'show-pending-jobs'",
")",
"@",
"click",
".",
"option",
"(",
"u'--site'",
",",
"help",
"=",
"u'site name'",
")",
"@",
"pass_context",
"def",
"show_pending_jobs",
"(",
"context",
",",
"site",
"=",
"None",
")",
":",
"from... | get diagnostic info about background jobs . | train | false |
53,338 | def get_top_state_rule_answers(exploration_id, state_name, rule_str_list):
return get_top_state_rule_answers_multi([(exploration_id, state_name)], rule_str_list)[0]
| [
"def",
"get_top_state_rule_answers",
"(",
"exploration_id",
",",
"state_name",
",",
"rule_str_list",
")",
":",
"return",
"get_top_state_rule_answers_multi",
"(",
"[",
"(",
"exploration_id",
",",
"state_name",
")",
"]",
",",
"rule_str_list",
")",
"[",
"0",
"]"
] | returns a list of top answers submitted to the given state in the given exploration which were mapped to any of the rules listed in rule_str_list . | train | false |
53,340 | def _recurse_config_to_dict(t_data):
if (not isinstance(t_data, type(None))):
if isinstance(t_data, list):
t_list = []
for i in t_data:
t_list.append(_recurse_config_to_dict(i))
return t_list
elif isinstance(t_data, dict):
t_dict = {}
for (k, v) in t_data.iteritems():
t_dict[k] = _recurse_config_to_dict(v)
return t_dict
elif hasattr(t_data, '__dict__'):
return _recurse_config_to_dict(t_data.__dict__)
else:
return _serializer(t_data)
| [
"def",
"_recurse_config_to_dict",
"(",
"t_data",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"t_data",
",",
"type",
"(",
"None",
")",
")",
")",
":",
"if",
"isinstance",
"(",
"t_data",
",",
"list",
")",
":",
"t_list",
"=",
"[",
"]",
"for",
"i",
"... | helper function to recurse through a vim object and attempt to return all child objects . | train | true |
53,342 | def translatePoints(elementNode, points, prefix):
translateVector3 = matrix.getCumulativeVector3Remove(Vector3(), elementNode, prefix)
if (abs(translateVector3) > 0.0):
euclidean.translateVector3Path(points, translateVector3)
| [
"def",
"translatePoints",
"(",
"elementNode",
",",
"points",
",",
"prefix",
")",
":",
"translateVector3",
"=",
"matrix",
".",
"getCumulativeVector3Remove",
"(",
"Vector3",
"(",
")",
",",
"elementNode",
",",
"prefix",
")",
"if",
"(",
"abs",
"(",
"translateVecto... | translate the points . | train | false |
53,343 | @login_required
def email_login(request):
if (request.method == u'POST'):
form = EmailForm(request.POST)
if form.is_valid():
return complete(request, u'email')
else:
form = EmailForm()
return render(request, u'accounts/email.html', {u'title': _(u'Register email'), u'form': form})
| [
"@",
"login_required",
"def",
"email_login",
"(",
"request",
")",
":",
"if",
"(",
"request",
".",
"method",
"==",
"u'POST'",
")",
":",
"form",
"=",
"EmailForm",
"(",
"request",
".",
"POST",
")",
"if",
"form",
".",
"is_valid",
"(",
")",
":",
"return",
... | connect email . | train | false |
53,344 | def validate_website(url):
validate_url = URLValidator()
if (url and ('://' not in url)):
url = (u'http://%s' % url)
try:
validate_url(url)
except ValidationError:
raise ValidationError(_('Enter a valid URL.'))
return url
| [
"def",
"validate_website",
"(",
"url",
")",
":",
"validate_url",
"=",
"URLValidator",
"(",
")",
"if",
"(",
"url",
"and",
"(",
"'://'",
"not",
"in",
"url",
")",
")",
":",
"url",
"=",
"(",
"u'http://%s'",
"%",
"url",
")",
"try",
":",
"validate_url",
"(... | validate and return a properly formatted website url . | train | false |
53,345 | def _average_flowgrams(mapping, flowgrams, sample_keys):
flows = defaultdict(list)
invert_map = invert_mapping(mapping)
for f in flowgrams:
key = invert_map[f.Name]
samples = sample_keys[key]
if (f.Name in samples):
flows[key].append(f.flowgram)
samples.remove(f.Name)
if (len(samples) == 0):
ave_flowgram = build_averaged_flowgram(flows[key])
ave_f = Flowgram(ave_flowgram, Name=key)
del flows[key]
(yield (ave_f, key))
| [
"def",
"_average_flowgrams",
"(",
"mapping",
",",
"flowgrams",
",",
"sample_keys",
")",
":",
"flows",
"=",
"defaultdict",
"(",
"list",
")",
"invert_map",
"=",
"invert_mapping",
"(",
"mapping",
")",
"for",
"f",
"in",
"flowgrams",
":",
"key",
"=",
"invert_map"... | average flowgrams according to cluster mapping . | train | false |
53,346 | def create_ikepolicy(name, profile=None, **kwargs):
conn = _auth(profile)
return conn.create_ikepolicy(name, **kwargs)
| [
"def",
"create_ikepolicy",
"(",
"name",
",",
"profile",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"conn",
"=",
"_auth",
"(",
"profile",
")",
"return",
"conn",
".",
"create_ikepolicy",
"(",
"name",
",",
"**",
"kwargs",
")"
] | creates a new ikepolicy cli example: . | train | true |
53,348 | def clean_orphaned_pyc(paths):
orphaned_pyc = []
for path in paths:
for pyc_path in stem.util.system.files_with_suffix(path, '.pyc'):
py_path = pyc_path[:(-1)]
pycache = ('%s__pycache__%s' % (os.path.sep, os.path.sep))
if (pycache in pyc_path):
(directory, pycache_filename) = pyc_path.split(pycache, 1)
if (not pycache_filename.endswith('.pyc')):
continue
py_path = os.path.join(directory, (pycache_filename.split('.')[0] + '.py'))
if (not os.path.exists(py_path)):
orphaned_pyc.append(pyc_path)
os.remove(pyc_path)
return orphaned_pyc
| [
"def",
"clean_orphaned_pyc",
"(",
"paths",
")",
":",
"orphaned_pyc",
"=",
"[",
"]",
"for",
"path",
"in",
"paths",
":",
"for",
"pyc_path",
"in",
"stem",
".",
"util",
".",
"system",
".",
"files_with_suffix",
"(",
"path",
",",
"'.pyc'",
")",
":",
"py_path",... | deletes any file with a * . | train | false |
53,350 | def getSender(email):
sender = email['From']
m = re.match('(.*)\\s<.*>', sender)
if m:
return m.group(1)
return sender
| [
"def",
"getSender",
"(",
"email",
")",
":",
"sender",
"=",
"email",
"[",
"'From'",
"]",
"m",
"=",
"re",
".",
"match",
"(",
"'(.*)\\\\s<.*>'",
",",
"sender",
")",
"if",
"m",
":",
"return",
"m",
".",
"group",
"(",
"1",
")",
"return",
"sender"
] | returns the best-guess sender of an email . | train | false |
53,351 | def test_routing_class_with_cli_commands():
@hug.object(name='git', version='1.0.0')
class GIT(object, ):
'An example of command like calls via an Object'
@hug.object.cli
def push(self, branch='master'):
return 'Pushing {}'.format(branch)
@hug.object.cli
def pull(self, branch='master'):
return 'Pulling {}'.format(branch)
assert ('token' in hug.test.cli(GIT.push, branch='token'))
assert ('another token' in hug.test.cli(GIT.pull, branch='another token'))
| [
"def",
"test_routing_class_with_cli_commands",
"(",
")",
":",
"@",
"hug",
".",
"object",
"(",
"name",
"=",
"'git'",
",",
"version",
"=",
"'1.0.0'",
")",
"class",
"GIT",
"(",
"object",
",",
")",
":",
"@",
"hug",
".",
"object",
".",
"cli",
"def",
"push",... | basic operation test . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.