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 |
|---|---|---|---|---|---|
12,700 | def do_wordcount(s):
return len(_word_re.findall(s))
| [
"def",
"do_wordcount",
"(",
"s",
")",
":",
"return",
"len",
"(",
"_word_re",
".",
"findall",
"(",
"s",
")",
")"
] | count the words in that string . | train | false |
12,701 | def reap_threads(func):
if (not thread):
return func
@functools.wraps(func)
def decorator(*args):
key = threading_setup()
try:
return func(*args)
finally:
threading_cleanup(*key)
return decorator
| [
"def",
"reap_threads",
"(",
"func",
")",
":",
"if",
"(",
"not",
"thread",
")",
":",
"return",
"func",
"@",
"functools",
".",
"wraps",
"(",
"func",
")",
"def",
"decorator",
"(",
"*",
"args",
")",
":",
"key",
"=",
"threading_setup",
"(",
")",
"try",
... | use this function when threads are being used . | train | false |
12,702 | def modClearRefs(s, titlesRefs, namesRefs, charactersRefs):
s = modClearTitleRefs(s, {}, {}, {})
s = modClearCharacterRefs(s, {}, {}, {})
return modClearNameRefs(s, {}, {}, {})
| [
"def",
"modClearRefs",
"(",
"s",
",",
"titlesRefs",
",",
"namesRefs",
",",
"charactersRefs",
")",
":",
"s",
"=",
"modClearTitleRefs",
"(",
"s",
",",
"{",
"}",
",",
"{",
"}",
",",
"{",
"}",
")",
"s",
"=",
"modClearCharacterRefs",
"(",
"s",
",",
"{",
... | remove titles . | train | false |
12,703 | def module_content(page, response):
regexp = '<!-- module_content -->(?P<module_content>.*?)<!-- /module_content -->'
blocks = re.finditer(regexp, page, re.DOTALL)
for block in blocks:
response['module_content'] = block.group('module_content').strip()
return response
| [
"def",
"module_content",
"(",
"page",
",",
"response",
")",
":",
"regexp",
"=",
"'<!-- module_content -->(?P<module_content>.*?)<!-- /module_content -->'",
"blocks",
"=",
"re",
".",
"finditer",
"(",
"regexp",
",",
"page",
",",
"re",
".",
"DOTALL",
")",
"for",
"blo... | extract module_content . | train | false |
12,706 | def _prefix_description_for_number(data, longest_prefix, numobj, lang, script=None, region=None):
e164_num = format_number(numobj, PhoneNumberFormat.E164)
if (not e164_num.startswith(U_PLUS)):
raise Exception('Expect E164 number to start with +')
for prefix_len in range(longest_prefix, 0, (-1)):
prefix = e164_num[1:(1 + prefix_len)]
if (prefix in data):
name = _find_lang(data[prefix], lang, script, region)
if (name is not None):
return name
else:
return U_EMPTY_STRING
return U_EMPTY_STRING
| [
"def",
"_prefix_description_for_number",
"(",
"data",
",",
"longest_prefix",
",",
"numobj",
",",
"lang",
",",
"script",
"=",
"None",
",",
"region",
"=",
"None",
")",
":",
"e164_num",
"=",
"format_number",
"(",
"numobj",
",",
"PhoneNumberFormat",
".",
"E164",
... | return a text description of a phonenumber for the given language . | train | true |
12,707 | def _namespace_to_ord(namespace):
n = 0
for (i, c) in enumerate(namespace):
n += ((_LEX_DISTANCE[((MAX_NAMESPACE_LENGTH - i) - 1)] * NAMESPACE_CHARACTERS.index(c)) + 1)
return n
| [
"def",
"_namespace_to_ord",
"(",
"namespace",
")",
":",
"n",
"=",
"0",
"for",
"(",
"i",
",",
"c",
")",
"in",
"enumerate",
"(",
"namespace",
")",
":",
"n",
"+=",
"(",
"(",
"_LEX_DISTANCE",
"[",
"(",
"(",
"MAX_NAMESPACE_LENGTH",
"-",
"i",
")",
"-",
"... | converts a namespace string into an int representing its lexographic order . | train | true |
12,708 | def dict_to_numpy_array2(d, mapping=None):
import numpy
if (mapping is None):
s = set(d.keys())
for (k, v) in d.items():
s.update(v.keys())
mapping = dict(zip(s, range(len(s))))
n = len(mapping)
a = numpy.zeros((n, n))
for (k1, i) in mapping.items():
for (k2, j) in mapping.items():
try:
a[(i, j)] = d[k1][k2]
except KeyError:
pass
return a
| [
"def",
"dict_to_numpy_array2",
"(",
"d",
",",
"mapping",
"=",
"None",
")",
":",
"import",
"numpy",
"if",
"(",
"mapping",
"is",
"None",
")",
":",
"s",
"=",
"set",
"(",
"d",
".",
"keys",
"(",
")",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",
"d",
... | convert a dictionary of dictionaries to a 2d numpy array with optional mapping . | train | false |
12,710 | def list_states(saltenv='base'):
return __context__['fileclient'].list_states(saltenv)
| [
"def",
"list_states",
"(",
"saltenv",
"=",
"'base'",
")",
":",
"return",
"__context__",
"[",
"'fileclient'",
"]",
".",
"list_states",
"(",
"saltenv",
")"
] | list all the available state modules in an environment . | train | false |
12,713 | def close_cover_tilt(hass, entity_id=None):
data = ({ATTR_ENTITY_ID: entity_id} if entity_id else None)
hass.services.call(DOMAIN, SERVICE_CLOSE_COVER_TILT, data)
| [
"def",
"close_cover_tilt",
"(",
"hass",
",",
"entity_id",
"=",
"None",
")",
":",
"data",
"=",
"(",
"{",
"ATTR_ENTITY_ID",
":",
"entity_id",
"}",
"if",
"entity_id",
"else",
"None",
")",
"hass",
".",
"services",
".",
"call",
"(",
"DOMAIN",
",",
"SERVICE_CL... | close all or specified cover tilt . | train | false |
12,716 | def asset_spec_from_abspath(abspath, package):
if (getattr(package, '__name__', None) == '__main__'):
return abspath
pp = (package_path(package) + os.path.sep)
if abspath.startswith(pp):
relpath = abspath[len(pp):]
return ('%s:%s' % (package_name(package), relpath.replace(os.path.sep, '/')))
return abspath
| [
"def",
"asset_spec_from_abspath",
"(",
"abspath",
",",
"package",
")",
":",
"if",
"(",
"getattr",
"(",
"package",
",",
"'__name__'",
",",
"None",
")",
"==",
"'__main__'",
")",
":",
"return",
"abspath",
"pp",
"=",
"(",
"package_path",
"(",
"package",
")",
... | try to convert an absolute path to a resource in a package to a resource specification if possible; otherwise return the absolute path . | train | false |
12,718 | @cache_permission
def can_add_comment(user, project):
return check_permission(user, project, 'trans.add_comment')
| [
"@",
"cache_permission",
"def",
"can_add_comment",
"(",
"user",
",",
"project",
")",
":",
"return",
"check_permission",
"(",
"user",
",",
"project",
",",
"'trans.add_comment'",
")"
] | checks whether user can add comment for given project . | train | false |
12,720 | def Download(url):
FilenameFromUrl = (lambda url: urlparse.urlparse(url)[2].split('/')[(-1)])
FilenameFromHandler = None
for handler in _realurl_handlers:
url4dnld = handler(url)
if (not url4dnld):
continue
if isinstance(url4dnld, tuple):
(FilenameFromHandler, url) = url4dnld
else:
url = url4dnld
break
dl = FileDownload()
resp = dl.open(url)
if FilenameFromHandler:
filename = FilenameFromHandler
elif dl.filename:
filename = dl.filename
else:
filename = FilenameFromUrl(dl.realurl)
if (not filename):
filename = 'NoName'
if (resp.status_code == 413):
return ('too large', filename, '')
elif (resp.status_code not in (200, 206)):
return ('download failed', filename, '')
elif (not resp.content):
return ('not resuming', filename, '')
else:
return ('', filename, resp.content)
| [
"def",
"Download",
"(",
"url",
")",
":",
"FilenameFromUrl",
"=",
"(",
"lambda",
"url",
":",
"urlparse",
".",
"urlparse",
"(",
"url",
")",
"[",
"2",
"]",
".",
"split",
"(",
"'/'",
")",
"[",
"(",
"-",
"1",
")",
"]",
")",
"FilenameFromHandler",
"=",
... | filedownload工具函数，简化文件下载工作 返回一个元组 . | train | false |
12,721 | def compare_torrents(torrent_1, torrent_2):
files1 = [files for files in torrent_1['metainfo'].get_files_with_length() if (files[1] > (1024 * 1024))]
files2 = [files for files in torrent_2['metainfo'].get_files_with_length() if (files[1] > (1024 * 1024))]
if (len(files1) == len(files2)):
for ft1 in files1:
for ft2 in files2:
if ((ft1[1] != ft2[1]) or (levenshtein_dist(ft1[0], ft2[0]) > SIMILARITY_TRESHOLD)):
return False
return True
return False
| [
"def",
"compare_torrents",
"(",
"torrent_1",
",",
"torrent_2",
")",
":",
"files1",
"=",
"[",
"files",
"for",
"files",
"in",
"torrent_1",
"[",
"'metainfo'",
"]",
".",
"get_files_with_length",
"(",
")",
"if",
"(",
"files",
"[",
"1",
"]",
">",
"(",
"1024",
... | comparing swarms . | train | false |
12,724 | def get_current_traceback(ignore_system_exceptions=False, show_hidden_frames=False, skip=0):
(exc_type, exc_value, tb) = sys.exc_info()
if (ignore_system_exceptions and (exc_type in system_exceptions)):
raise
for x in range_type(skip):
if (tb.tb_next is None):
break
tb = tb.tb_next
tb = Traceback(exc_type, exc_value, tb)
if (not show_hidden_frames):
tb.filter_hidden_frames()
return tb
| [
"def",
"get_current_traceback",
"(",
"ignore_system_exceptions",
"=",
"False",
",",
"show_hidden_frames",
"=",
"False",
",",
"skip",
"=",
"0",
")",
":",
"(",
"exc_type",
",",
"exc_value",
",",
"tb",
")",
"=",
"sys",
".",
"exc_info",
"(",
")",
"if",
"(",
... | get the current exception info as traceback object . | train | true |
12,728 | def _consteq(str1, str2):
return ((len(str1) == len(str2)) and (sum(((ord(x) ^ ord(y)) for (x, y) in zip(str1, str2))) == 0))
| [
"def",
"_consteq",
"(",
"str1",
",",
"str2",
")",
":",
"return",
"(",
"(",
"len",
"(",
"str1",
")",
"==",
"len",
"(",
"str2",
")",
")",
"and",
"(",
"sum",
"(",
"(",
"(",
"ord",
"(",
"x",
")",
"^",
"ord",
"(",
"y",
")",
")",
"for",
"(",
"x... | constant-time string comparison . | train | false |
12,731 | def multi_file_load_config(*filenames):
configs = []
profiles = []
for filename in filenames:
try:
loaded = load_config(filename)
except botocore.exceptions.ConfigNotFound:
continue
profiles.append(loaded.pop('profiles'))
configs.append(loaded)
merged_config = _merge_list_of_dicts(configs)
merged_profiles = _merge_list_of_dicts(profiles)
merged_config['profiles'] = merged_profiles
return merged_config
| [
"def",
"multi_file_load_config",
"(",
"*",
"filenames",
")",
":",
"configs",
"=",
"[",
"]",
"profiles",
"=",
"[",
"]",
"for",
"filename",
"in",
"filenames",
":",
"try",
":",
"loaded",
"=",
"load_config",
"(",
"filename",
")",
"except",
"botocore",
".",
"... | load and combine multiple ini configs with profiles . | train | false |
12,732 | @sync_performer
def perform_update_s3_error_page(dispatcher, intent):
s3 = boto.connect_s3()
bucket = s3.get_bucket(intent.bucket)
config = bucket.get_website_configuration_obj()
new_error_key = intent.error_key
old_error_key = config.error_key
if (old_error_key == new_error_key):
return None
else:
config.error_key = new_error_key
bucket.set_website_configuration(config)
return old_error_key
| [
"@",
"sync_performer",
"def",
"perform_update_s3_error_page",
"(",
"dispatcher",
",",
"intent",
")",
":",
"s3",
"=",
"boto",
".",
"connect_s3",
"(",
")",
"bucket",
"=",
"s3",
".",
"get_bucket",
"(",
"intent",
".",
"bucket",
")",
"config",
"=",
"bucket",
".... | see :class:updates3errorpage . | train | false |
12,733 | def test_reason(monkeypatch):
def has_reason(ids, force, reason):
assert (reason == 'expiry')
monkeypatch.setattr(SIGN_ADDONS, has_reason)
call_command('sign_addons', 123, reason='expiry')
| [
"def",
"test_reason",
"(",
"monkeypatch",
")",
":",
"def",
"has_reason",
"(",
"ids",
",",
"force",
",",
"reason",
")",
":",
"assert",
"(",
"reason",
"==",
"'expiry'",
")",
"monkeypatch",
".",
"setattr",
"(",
"SIGN_ADDONS",
",",
"has_reason",
")",
"call_com... | you can pass a reason . | train | false |
12,734 | def skip_if_fake(func):
def _skipper(*args, **kw):
'Wrapped skipper function.'
if FLAGS.fake_tests:
raise unittest.SkipTest('Test cannot be run in fake mode')
else:
return func(*args, **kw)
return _skipper
| [
"def",
"skip_if_fake",
"(",
"func",
")",
":",
"def",
"_skipper",
"(",
"*",
"args",
",",
"**",
"kw",
")",
":",
"if",
"FLAGS",
".",
"fake_tests",
":",
"raise",
"unittest",
".",
"SkipTest",
"(",
"'Test cannot be run in fake mode'",
")",
"else",
":",
"return",... | decorator that skips a test if running in fake mode . | train | false |
12,735 | @public
def vfield(symbols, domain, order=lex):
_field = FracField(symbols, domain, order)
pollute([sym.name for sym in _field.symbols], _field.gens)
return _field
| [
"@",
"public",
"def",
"vfield",
"(",
"symbols",
",",
"domain",
",",
"order",
"=",
"lex",
")",
":",
"_field",
"=",
"FracField",
"(",
"symbols",
",",
"domain",
",",
"order",
")",
"pollute",
"(",
"[",
"sym",
".",
"name",
"for",
"sym",
"in",
"_field",
... | construct new rational function field and inject generators into global namespace . | train | false |
12,738 | def _use_accelerator(state):
global _convert_agg_to_wx_image
global _convert_agg_to_wx_bitmap
if (getattr(wx, '__version__', '0.0')[0:3] < '2.8'):
if (state and (_wxagg is not None)):
_convert_agg_to_wx_image = _wxagg.convert_agg_to_wx_image
_convert_agg_to_wx_bitmap = _wxagg.convert_agg_to_wx_bitmap
else:
_convert_agg_to_wx_image = _py_convert_agg_to_wx_image
_convert_agg_to_wx_bitmap = _py_convert_agg_to_wx_bitmap
else:
_convert_agg_to_wx_image = _py_WX28_convert_agg_to_wx_image
_convert_agg_to_wx_bitmap = _py_WX28_convert_agg_to_wx_bitmap
| [
"def",
"_use_accelerator",
"(",
"state",
")",
":",
"global",
"_convert_agg_to_wx_image",
"global",
"_convert_agg_to_wx_bitmap",
"if",
"(",
"getattr",
"(",
"wx",
",",
"'__version__'",
",",
"'0.0'",
")",
"[",
"0",
":",
"3",
"]",
"<",
"'2.8'",
")",
":",
"if",
... | enable or disable the wxagg accelerator . | train | false |
12,739 | def is_db_connection_error(args):
conn_err_codes = ('2002', '2003', '2006')
for err_code in conn_err_codes:
if (args.find(err_code) != (-1)):
return True
return False
| [
"def",
"is_db_connection_error",
"(",
"args",
")",
":",
"conn_err_codes",
"=",
"(",
"'2002'",
",",
"'2003'",
",",
"'2006'",
")",
"for",
"err_code",
"in",
"conn_err_codes",
":",
"if",
"(",
"args",
".",
"find",
"(",
"err_code",
")",
"!=",
"(",
"-",
"1",
... | return true if error in connecting to db . | train | false |
12,740 | def _resolveIPv6(ip, port):
return socket.getaddrinfo(ip, port, 0, 0, 0, _NUMERIC_ONLY)[0][4]
| [
"def",
"_resolveIPv6",
"(",
"ip",
",",
"port",
")",
":",
"return",
"socket",
".",
"getaddrinfo",
"(",
"ip",
",",
"port",
",",
"0",
",",
"0",
",",
"0",
",",
"_NUMERIC_ONLY",
")",
"[",
"0",
"]",
"[",
"4",
"]"
] | resolve an ipv6 literal into an ipv6 address . | train | false |
12,741 | def create_tag(name=u'', ref=u'', sign=False, settings=None):
view = new_create_tag(name=name, ref=ref, sign=sign, settings=settings, parent=qtutils.active_window())
view.show()
view.raise_()
return view
| [
"def",
"create_tag",
"(",
"name",
"=",
"u''",
",",
"ref",
"=",
"u''",
",",
"sign",
"=",
"False",
",",
"settings",
"=",
"None",
")",
":",
"view",
"=",
"new_create_tag",
"(",
"name",
"=",
"name",
",",
"ref",
"=",
"ref",
",",
"sign",
"=",
"sign",
",... | entry point for external callers . | train | false |
12,742 | @frame_transform_graph.transform(coord.StaticMatrixTransform, Sagittarius, coord.Galactic)
def sgr_to_galactic():
return matrix_transpose(SGR_MATRIX)
| [
"@",
"frame_transform_graph",
".",
"transform",
"(",
"coord",
".",
"StaticMatrixTransform",
",",
"Sagittarius",
",",
"coord",
".",
"Galactic",
")",
"def",
"sgr_to_galactic",
"(",
")",
":",
"return",
"matrix_transpose",
"(",
"SGR_MATRIX",
")"
] | compute the transformation matrix from heliocentric sgr coordinates to spherical galactic . | train | false |
12,744 | def locate_profile(profile='default'):
from IPython.core.profiledir import ProfileDir, ProfileDirError
try:
pd = ProfileDir.find_profile_dir_by_name(get_ipython_dir(), profile)
except ProfileDirError:
raise IOError(("Couldn't find profile %r" % profile))
return pd.location
| [
"def",
"locate_profile",
"(",
"profile",
"=",
"'default'",
")",
":",
"from",
"IPython",
".",
"core",
".",
"profiledir",
"import",
"ProfileDir",
",",
"ProfileDirError",
"try",
":",
"pd",
"=",
"ProfileDir",
".",
"find_profile_dir_by_name",
"(",
"get_ipython_dir",
... | find the path to the folder associated with a given profile . | train | true |
12,746 | def example_certificates_status(course_key):
return ExampleCertificateSet.latest_status(course_key)
| [
"def",
"example_certificates_status",
"(",
"course_key",
")",
":",
"return",
"ExampleCertificateSet",
".",
"latest_status",
"(",
"course_key",
")"
] | check the status of example certificates for a course . | train | false |
12,747 | def dummy_deepcopy(*arg):
return None
| [
"def",
"dummy_deepcopy",
"(",
"*",
"arg",
")",
":",
"return",
"None"
] | this is necessary to prevent deepcopy() on anonymous user object that now contains reference to request . | train | false |
12,748 | def validate_backup_retention_period(days):
days = positive_integer(days)
if (int(days) > 35):
raise ValueError('DBInstance BackupRetentionPeriod cannot be larger than 35 days.')
return days
| [
"def",
"validate_backup_retention_period",
"(",
"days",
")",
":",
"days",
"=",
"positive_integer",
"(",
"days",
")",
"if",
"(",
"int",
"(",
"days",
")",
">",
"35",
")",
":",
"raise",
"ValueError",
"(",
"'DBInstance BackupRetentionPeriod cannot be larger than 35 days... | validate backupretentionperiod for dbinstance . | train | false |
12,750 | def make_long_description():
readme_path = README_PATH
readme_md = strip_html_comments(read(readme_path))
history_md = strip_html_comments(read(HISTORY_PATH))
license_md = ('License\n=======\n\n' + read(LICENSE_PATH))
sections = [readme_md, history_md, license_md]
md_description = '\n\n'.join(sections)
md_ext = os.path.splitext(readme_path)[1]
md_description_path = make_temp_path(RST_DESCRIPTION_PATH, new_ext=md_ext)
write(md_description, md_description_path)
rst_temp_path = make_temp_path(RST_DESCRIPTION_PATH)
long_description = convert_md_to_rst(md_path=md_description_path, rst_temp_path=rst_temp_path)
return '\n'.join([RST_LONG_DESCRIPTION_INTRO, long_description])
| [
"def",
"make_long_description",
"(",
")",
":",
"readme_path",
"=",
"README_PATH",
"readme_md",
"=",
"strip_html_comments",
"(",
"read",
"(",
"readme_path",
")",
")",
"history_md",
"=",
"strip_html_comments",
"(",
"read",
"(",
"HISTORY_PATH",
")",
")",
"license_md"... | generate the rest long_description for setup() from source files . | train | true |
12,751 | def _untested_error(where):
raise RuntimeError(('Unknown %s failure' % (where,)))
| [
"def",
"_untested_error",
"(",
"where",
")",
":",
"raise",
"RuntimeError",
"(",
"(",
"'Unknown %s failure'",
"%",
"(",
"where",
",",
")",
")",
")"
] | an openssl api failed somehow . | train | false |
12,754 | def royal_road1(individual, order):
nelem = (len(individual) / order)
max_value = int(((2 ** order) - 1))
total = 0
for i in xrange(nelem):
value = int(''.join(map(str, individual[(i * order):((i * order) + order)])), 2)
total += (int(order) * int((value / max_value)))
return (total,)
| [
"def",
"royal_road1",
"(",
"individual",
",",
"order",
")",
":",
"nelem",
"=",
"(",
"len",
"(",
"individual",
")",
"/",
"order",
")",
"max_value",
"=",
"int",
"(",
"(",
"(",
"2",
"**",
"order",
")",
"-",
"1",
")",
")",
"total",
"=",
"0",
"for",
... | royal road function r1 as presented by melanie mitchell in : "an introduction to genetic algorithms" . | train | false |
12,756 | def verifyResults(lines, testRegex):
lines = removePrompts(lines)
chopped = ''.join([line[:(-1)] for line in lines])
Assert(re.match(testRegex, chopped), ((('Expected Regular Expression=' + testRegex) + '\nActual Lines=') + chopped))
| [
"def",
"verifyResults",
"(",
"lines",
",",
"testRegex",
")",
":",
"lines",
"=",
"removePrompts",
"(",
"lines",
")",
"chopped",
"=",
"''",
".",
"join",
"(",
"[",
"line",
"[",
":",
"(",
"-",
"1",
")",
"]",
"for",
"line",
"in",
"lines",
"]",
")",
"A... | verifies that a set of lines match a regular expression . | train | false |
12,757 | def _NewFacetFromPb(pb):
name = _DecodeUTF8(pb.name())
val_type = pb.value().type()
value = _DecodeValue(_GetValue(pb.value()), val_type)
if (val_type == document_pb.FacetValue.ATOM):
return AtomFacet(name, value)
elif (val_type == document_pb.FacetValue.NUMBER):
return NumberFacet(name, value)
return InvalidRequest(('Unknown facet value type %d' % val_type))
| [
"def",
"_NewFacetFromPb",
"(",
"pb",
")",
":",
"name",
"=",
"_DecodeUTF8",
"(",
"pb",
".",
"name",
"(",
")",
")",
"val_type",
"=",
"pb",
".",
"value",
"(",
")",
".",
"type",
"(",
")",
"value",
"=",
"_DecodeValue",
"(",
"_GetValue",
"(",
"pb",
".",
... | constructs a facet from a document_pb . | train | false |
12,758 | @register.simple_tag
def crossorigin():
if absolute_uri(settings.STATIC_URL).startswith(options.get('system.url-prefix')):
return ''
return ' crossorigin="anonymous"'
| [
"@",
"register",
".",
"simple_tag",
"def",
"crossorigin",
"(",
")",
":",
"if",
"absolute_uri",
"(",
"settings",
".",
"STATIC_URL",
")",
".",
"startswith",
"(",
"options",
".",
"get",
"(",
"'system.url-prefix'",
")",
")",
":",
"return",
"''",
"return",
"' c... | returns an additional crossorigin="anonymous" snippet for use in a <script> tag if our asset urls are from a different domain than the system . | train | false |
12,759 | def construct_pagination_urls(request, course_id, api_next_url, api_previous_url):
def lms_url(url):
'\n Create lms url from api url.\n '
if (url is None):
return None
keys = ('page', 'page_size', 'text')
parsed = urlparse.urlparse(url)
query_params = urlparse.parse_qs(parsed.query)
encoded_query_params = urlencode({key: query_params.get(key)[0] for key in keys if (key in query_params)})
return '{}?{}'.format(request.build_absolute_uri(base_url), encoded_query_params)
base_url = reverse('notes', kwargs={'course_id': course_id})
next_url = lms_url(api_next_url)
previous_url = lms_url(api_previous_url)
return (next_url, previous_url)
| [
"def",
"construct_pagination_urls",
"(",
"request",
",",
"course_id",
",",
"api_next_url",
",",
"api_previous_url",
")",
":",
"def",
"lms_url",
"(",
"url",
")",
":",
"if",
"(",
"url",
"is",
"None",
")",
":",
"return",
"None",
"keys",
"=",
"(",
"'page'",
... | construct next and previous urls for lms . | train | false |
12,760 | def validate_license_model(license_model):
if (license_model not in VALID_LICENSE_MODELS):
raise ValueError(('DBInstance LicenseModel must be one of: %s' % ', '.join(VALID_LICENSE_MODELS)))
return license_model
| [
"def",
"validate_license_model",
"(",
"license_model",
")",
":",
"if",
"(",
"license_model",
"not",
"in",
"VALID_LICENSE_MODELS",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'DBInstance LicenseModel must be one of: %s'",
"%",
"', '",
".",
"join",
"(",
"VALID_LICENSE_M... | validate licensemodel for dbinstance . | train | false |
12,761 | def unique_on(*groups):
def wrapper(cls):
cls.__indices__ = getattr(cls, '__indices__', [])
cls.__indices__.extend([{'key_or_list': [(key, pymongo.ASCENDING) for key in group], 'unique': True} for group in groups])
return cls
return wrapper
| [
"def",
"unique_on",
"(",
"*",
"groups",
")",
":",
"def",
"wrapper",
"(",
"cls",
")",
":",
"cls",
".",
"__indices__",
"=",
"getattr",
"(",
"cls",
",",
"'__indices__'",
",",
"[",
"]",
")",
"cls",
".",
"__indices__",
".",
"extend",
"(",
"[",
"{",
"'ke... | decorator for subclasses of storedobject . | train | false |
12,762 | def coerce_put_post(request):
if (request.method == 'PUT'):
if hasattr(request, '_post'):
del request._post
del request._files
try:
request.method = 'POST'
request._load_post_and_files()
request.method = 'PUT'
except AttributeError:
request.META['REQUEST_METHOD'] = 'POST'
request._load_post_and_files()
request.META['REQUEST_METHOD'] = 'PUT'
request.PUT = request.POST
| [
"def",
"coerce_put_post",
"(",
"request",
")",
":",
"if",
"(",
"request",
".",
"method",
"==",
"'PUT'",
")",
":",
"if",
"hasattr",
"(",
"request",
",",
"'_post'",
")",
":",
"del",
"request",
".",
"_post",
"del",
"request",
".",
"_files",
"try",
":",
... | django doesnt particularly understand rest . | train | true |
12,763 | def return_probe_from_definition(df, types):
args = df['args']
retval_type = df['retval_type']
printf_specifier = type_description(retval_type, types)['printf_specifier']
template = Template(RETURN_PROBE_TEMPLATE)
mapping = {'__LIBRARY__': df.get('library', ''), '__NAME__': df['api'], '__ARGS_FORMAT_STRING__': arguments_format_string(args, types), '__RETVAL_FORMAT_SPECIFIER__': printf_specifier, '__ARGUMENTS__': arguments_section(args, types), '__RETVAL__': retval_section(retval_type, types), '__ARGUMENTS_POP_FROM_STACK__': pop_from_stack_section(args)}
return template.substitute(mapping)
| [
"def",
"return_probe_from_definition",
"(",
"df",
",",
"types",
")",
":",
"args",
"=",
"df",
"[",
"'args'",
"]",
"retval_type",
"=",
"df",
"[",
"'retval_type'",
"]",
"printf_specifier",
"=",
"type_description",
"(",
"retval_type",
",",
"types",
")",
"[",
"'p... | generates a return dtrace probe from the given api definition . | train | false |
12,764 | def shift_series(s):
s0 = s.copy()
s0 = s0.shift(1)
s0.iloc[0] = 0.0
return s0
| [
"def",
"shift_series",
"(",
"s",
")",
":",
"s0",
"=",
"s",
".",
"copy",
"(",
")",
"s0",
"=",
"s0",
".",
"shift",
"(",
"1",
")",
"s0",
".",
"iloc",
"[",
"0",
"]",
"=",
"0.0",
"return",
"s0"
] | produces a copy of the provided series shifted by one . | train | false |
12,765 | def tensorsymmetry(*args):
from sympy.combinatorics import Permutation
def tableau2bsgs(a):
if (len(a) == 1):
n = a[0]
bsgs = get_symmetric_group_sgs(n, 1)
elif all(((x == 1) for x in a)):
n = len(a)
bsgs = get_symmetric_group_sgs(n)
elif (a == [2, 2]):
bsgs = riemann_bsgs
else:
raise NotImplementedError
return bsgs
if (not args):
return TensorSymmetry(Tuple(), Tuple(Permutation(1)))
if ((len(args) == 2) and isinstance(args[1][0], Permutation)):
return TensorSymmetry(args)
(base, sgs) = tableau2bsgs(args[0])
for a in args[1:]:
(basex, sgsx) = tableau2bsgs(a)
(base, sgs) = bsgs_direct_product(base, sgs, basex, sgsx)
return TensorSymmetry(Tuple(base, sgs))
| [
"def",
"tensorsymmetry",
"(",
"*",
"args",
")",
":",
"from",
"sympy",
".",
"combinatorics",
"import",
"Permutation",
"def",
"tableau2bsgs",
"(",
"a",
")",
":",
"if",
"(",
"len",
"(",
"a",
")",
"==",
"1",
")",
":",
"n",
"=",
"a",
"[",
"0",
"]",
"b... | return a tensorsymmetry object . | train | false |
12,766 | def getInfillDictionary(arounds, aroundWidth, infillInset, infillWidth, pixelTable, rotatedLoops, testLoops=None):
slightlyGreaterThanInfillInset = (intercircle.globalIntercircleMultiplier * infillInset)
allPoints = intercircle.getPointsFromLoops(rotatedLoops, infillInset, 0.7)
centers = intercircle.getCentersFromPoints(allPoints, slightlyGreaterThanInfillInset)
infillDictionary = {}
for center in centers:
insetCenter = intercircle.getSimplifiedInsetFromClockwiseLoop(center, infillInset)
insetPoint = insetCenter[0]
if ((len(insetCenter) > 2) and intercircle.getIsLarge(insetCenter, infillInset) and euclidean.getIsInFilledRegion(rotatedLoops, insetPoint)):
around = euclidean.getSimplifiedLoop(center, infillInset)
euclidean.addLoopToPixelTable(around, pixelTable, aroundWidth)
arounds.append(around)
insetLoop = intercircle.getSimplifiedInsetFromClockwiseLoop(center, infillInset)
euclidean.addXIntersectionsFromLoopForTable(insetLoop, infillDictionary, infillWidth)
if (testLoops != None):
testLoops.append(insetLoop)
return infillDictionary
| [
"def",
"getInfillDictionary",
"(",
"arounds",
",",
"aroundWidth",
",",
"infillInset",
",",
"infillWidth",
",",
"pixelTable",
",",
"rotatedLoops",
",",
"testLoops",
"=",
"None",
")",
":",
"slightlyGreaterThanInfillInset",
"=",
"(",
"intercircle",
".",
"globalIntercir... | get combined fill loops which include most of the points . | train | false |
12,767 | def GetQueryNodeTextUnicode(node):
if ((node.getType() == QueryParser.VALUE) and (len(node.children) >= 2)):
return u''.join((c.getText() for c in node.children[1:]))
elif (node.getType() == QueryParser.VALUE):
return None
return node.getText()
| [
"def",
"GetQueryNodeTextUnicode",
"(",
"node",
")",
":",
"if",
"(",
"(",
"node",
".",
"getType",
"(",
")",
"==",
"QueryParser",
".",
"VALUE",
")",
"and",
"(",
"len",
"(",
"node",
".",
"children",
")",
">=",
"2",
")",
")",
":",
"return",
"u''",
".",... | returns the unicode text from node . | train | false |
12,768 | def assert_request_user_has_resource_api_permission(request, resource_api, permission_type):
has_permission = request_user_has_resource_api_permission(request=request, resource_api=resource_api, permission_type=permission_type)
if (not has_permission):
user_db = get_user_db_from_request(request=request)
raise ResourceAccessDeniedError(user_db=user_db, resource_db=resource_api, permission_type=permission_type)
| [
"def",
"assert_request_user_has_resource_api_permission",
"(",
"request",
",",
"resource_api",
",",
"permission_type",
")",
":",
"has_permission",
"=",
"request_user_has_resource_api_permission",
"(",
"request",
"=",
"request",
",",
"resource_api",
"=",
"resource_api",
",",... | check that currently logged-in user has specified permission for the resource which is to be created . | train | false |
12,769 | def processSVGElementg(elementNode, svgReader):
if ('id' not in elementNode.attributes):
return
idString = elementNode.attributes['id']
if ('beginningOfControlSection' in elementNode.attributes):
if (elementNode.attributes['beginningOfControlSection'].lower()[:1] == 't'):
svgReader.stopProcessing = True
return
idStringLower = idString.lower()
zIndex = idStringLower.find('z:')
if (zIndex < 0):
idStringLower = getLabelString(elementNode.attributes)
zIndex = idStringLower.find('z:')
if (zIndex < 0):
return
floatFromValue = euclidean.getFloatFromValue(idStringLower[(zIndex + len('z:')):].strip())
if (floatFromValue != None):
svgReader.z = floatFromValue
| [
"def",
"processSVGElementg",
"(",
"elementNode",
",",
"svgReader",
")",
":",
"if",
"(",
"'id'",
"not",
"in",
"elementNode",
".",
"attributes",
")",
":",
"return",
"idString",
"=",
"elementNode",
".",
"attributes",
"[",
"'id'",
"]",
"if",
"(",
"'beginningOfCo... | process elementnode by svgreader . | train | false |
12,770 | def CDLMATHOLD(barDs, count, penetration=(-4e+37)):
return call_talib_with_ohlc(barDs, count, talib.CDLMATHOLD, penetration)
| [
"def",
"CDLMATHOLD",
"(",
"barDs",
",",
"count",
",",
"penetration",
"=",
"(",
"-",
"4e+37",
")",
")",
":",
"return",
"call_talib_with_ohlc",
"(",
"barDs",
",",
"count",
",",
"talib",
".",
"CDLMATHOLD",
",",
"penetration",
")"
] | mat hold . | train | false |
12,771 | @aborts
def test_require_single_missing_key():
require('blah')
| [
"@",
"aborts",
"def",
"test_require_single_missing_key",
"(",
")",
":",
"require",
"(",
"'blah'",
")"
] | when given a single non-existent key . | train | false |
12,772 | def csm_shape(csm):
return csm_properties(csm)[3]
| [
"def",
"csm_shape",
"(",
"csm",
")",
":",
"return",
"csm_properties",
"(",
"csm",
")",
"[",
"3",
"]"
] | return the shape field of the sparse variable . | train | false |
12,773 | def rss_warnings():
rss = RSS()
rss.channel.title = 'SABnzbd Warnings'
rss.channel.description = 'Overview of warnings/errors'
rss.channel.link = 'http://sabnzbd.org/'
rss.channel.language = 'en'
for warn in sabnzbd.GUIHANDLER.content():
item = Item()
item.title = warn
rss.addItem(item)
rss.channel.lastBuildDate = std_time(time.time())
rss.channel.pubDate = rss.channel.lastBuildDate
return rss.write()
| [
"def",
"rss_warnings",
"(",
")",
":",
"rss",
"=",
"RSS",
"(",
")",
"rss",
".",
"channel",
".",
"title",
"=",
"'SABnzbd Warnings'",
"rss",
".",
"channel",
".",
"description",
"=",
"'Overview of warnings/errors'",
"rss",
".",
"channel",
".",
"link",
"=",
"'h... | return an rss feed with last warnings/errors . | train | false |
12,774 | def model_format_dict(obj):
if isinstance(obj, (models.Model, models.base.ModelBase)):
opts = obj._meta
elif isinstance(obj, models.query.QuerySet):
opts = obj.model._meta
else:
opts = obj
return {'verbose_name': force_unicode(opts.verbose_name), 'verbose_name_plural': force_unicode(opts.verbose_name_plural)}
| [
"def",
"model_format_dict",
"(",
"obj",
")",
":",
"if",
"isinstance",
"(",
"obj",
",",
"(",
"models",
".",
"Model",
",",
"models",
".",
"base",
".",
"ModelBase",
")",
")",
":",
"opts",
"=",
"obj",
".",
"_meta",
"elif",
"isinstance",
"(",
"obj",
",",
... | return a dict with keys verbose_name and verbose_name_plural . | train | false |
12,775 | def load_nietzsche_dataset(path='data/nietzsche/'):
print 'Load or Download nietzsche dataset > {}'.format(path)
filename = 'nietzsche.txt'
url = 'https://s3.amazonaws.com/text-datasets/'
filepath = maybe_download_and_extract(filename, path, url)
with open(filepath, 'r') as f:
words = f.read()
return words
| [
"def",
"load_nietzsche_dataset",
"(",
"path",
"=",
"'data/nietzsche/'",
")",
":",
"print",
"'Load or Download nietzsche dataset > {}'",
".",
"format",
"(",
"path",
")",
"filename",
"=",
"'nietzsche.txt'",
"url",
"=",
"'https://s3.amazonaws.com/text-datasets/'",
"filepath",
... | load nietzsche dataset . | train | false |
12,776 | def get_custom_metric(client, project_id, custom_metric_type):
request = client.projects().metricDescriptors().list(name=project_id, filter='metric.type=starts_with("{}")'.format(custom_metric_type))
response = request.execute()
print 'ListCustomMetrics response:'
pprint.pprint(response)
try:
return response['metricDescriptors']
except KeyError:
return None
| [
"def",
"get_custom_metric",
"(",
"client",
",",
"project_id",
",",
"custom_metric_type",
")",
":",
"request",
"=",
"client",
".",
"projects",
"(",
")",
".",
"metricDescriptors",
"(",
")",
".",
"list",
"(",
"name",
"=",
"project_id",
",",
"filter",
"=",
"'m... | retrieve the custom metric we created . | train | false |
12,779 | def _CheckText(value, name='value', empty_ok=True):
return _ValidateString(value, name, MAXIMUM_FIELD_VALUE_LENGTH, empty_ok)
| [
"def",
"_CheckText",
"(",
"value",
",",
"name",
"=",
"'value'",
",",
"empty_ok",
"=",
"True",
")",
":",
"return",
"_ValidateString",
"(",
"value",
",",
"name",
",",
"MAXIMUM_FIELD_VALUE_LENGTH",
",",
"empty_ok",
")"
] | checks the field text is a valid string . | train | false |
12,780 | def get_system_date_time(utc_offset=None):
offset_time = _get_offset_time(utc_offset)
return datetime.strftime(offset_time, '%Y-%m-%d %H:%M:%S')
| [
"def",
"get_system_date_time",
"(",
"utc_offset",
"=",
"None",
")",
":",
"offset_time",
"=",
"_get_offset_time",
"(",
"utc_offset",
")",
"return",
"datetime",
".",
"strftime",
"(",
"offset_time",
",",
"'%Y-%m-%d %H:%M:%S'",
")"
] | get the system date/time . | train | false |
12,781 | def Arcsin(name, a=0, b=1):
return rv(name, ArcsinDistribution, (a, b))
| [
"def",
"Arcsin",
"(",
"name",
",",
"a",
"=",
"0",
",",
"b",
"=",
"1",
")",
":",
"return",
"rv",
"(",
"name",
",",
"ArcsinDistribution",
",",
"(",
"a",
",",
"b",
")",
")"
] | create a continuous random variable with an arcsin distribution . | train | false |
12,782 | def delete_virtual_disk_spec(client_factory, device):
virtual_device_config = client_factory.create('ns0:VirtualDeviceConfigSpec')
virtual_device_config.operation = 'remove'
virtual_device_config.fileOperation = 'destroy'
virtual_device_config.device = device
return virtual_device_config
| [
"def",
"delete_virtual_disk_spec",
"(",
"client_factory",
",",
"device",
")",
":",
"virtual_device_config",
"=",
"client_factory",
".",
"create",
"(",
"'ns0:VirtualDeviceConfigSpec'",
")",
"virtual_device_config",
".",
"operation",
"=",
"'remove'",
"virtual_device_config",
... | builds spec for the deletion of an already existing virtual disk from vm . | train | false |
12,784 | def unarchive(host, source_material):
if (source_material.endswith('.gz') or source_material.endswith('.gzip')):
host.run(('gunzip "%s"' % utils.sh_escape(source_material)))
source_material = '.'.join(source_material.split('.')[:(-1)])
elif source_material.endswith('bz2'):
host.run(('bunzip2 "%s"' % utils.sh_escape(source_material)))
source_material = '.'.join(source_material.split('.')[:(-1)])
if source_material.endswith('.tar'):
retval = host.run(('tar -C "%s" -xvf "%s"' % (utils.sh_escape(os.path.dirname(source_material)), utils.sh_escape(source_material))))
source_material = os.path.join(os.path.dirname(source_material), retval.stdout.split()[0])
return source_material
| [
"def",
"unarchive",
"(",
"host",
",",
"source_material",
")",
":",
"if",
"(",
"source_material",
".",
"endswith",
"(",
"'.gz'",
")",
"or",
"source_material",
".",
"endswith",
"(",
"'.gzip'",
")",
")",
":",
"host",
".",
"run",
"(",
"(",
"'gunzip \"%s\"'",
... | extract the contents of a tar or zip file at *archive_path* into the directory *dest* . | train | false |
12,785 | @utils.arg('network', metavar='<network>', help=_('UUID or label of network.'))
@deprecated_network
def do_network_show(cs, args):
network = utils.find_resource(cs.networks, args.network)
utils.print_dict(network.to_dict())
| [
"@",
"utils",
".",
"arg",
"(",
"'network'",
",",
"metavar",
"=",
"'<network>'",
",",
"help",
"=",
"_",
"(",
"'UUID or label of network.'",
")",
")",
"@",
"deprecated_network",
"def",
"do_network_show",
"(",
"cs",
",",
"args",
")",
":",
"network",
"=",
"uti... | show details about the given network . | train | false |
12,788 | def _filter_discardable_metadata(metadata):
return {name: val for (name, val) in metadata.items() if (val is not _DISCARD)}
| [
"def",
"_filter_discardable_metadata",
"(",
"metadata",
")",
":",
"return",
"{",
"name",
":",
"val",
"for",
"(",
"name",
",",
"val",
")",
"in",
"metadata",
".",
"items",
"(",
")",
"if",
"(",
"val",
"is",
"not",
"_DISCARD",
")",
"}"
] | return a copy of a dict . | train | false |
12,789 | @conf.commands.register
def wrpcap(filename, pkt, *args, **kargs):
with PcapWriter(filename, *args, **kargs) as fdesc:
fdesc.write(pkt)
| [
"@",
"conf",
".",
"commands",
".",
"register",
"def",
"wrpcap",
"(",
"filename",
",",
"pkt",
",",
"*",
"args",
",",
"**",
"kargs",
")",
":",
"with",
"PcapWriter",
"(",
"filename",
",",
"*",
"args",
",",
"**",
"kargs",
")",
"as",
"fdesc",
":",
"fdes... | write a list of packets to a pcap file gz: set to 1 to save a gzipped capture linktype: force linktype value endianness: "<" or ">" . | train | false |
12,790 | def make_conditional(response, last_modified=None, etag=None, max_age=0):
response.cache_control.must_revalidate = True
response.cache_control.max_age = max_age
if last_modified:
response.last_modified = last_modified
if etag:
response.set_etag(etag)
return response.make_conditional(request.httprequest)
| [
"def",
"make_conditional",
"(",
"response",
",",
"last_modified",
"=",
"None",
",",
"etag",
"=",
"None",
",",
"max_age",
"=",
"0",
")",
":",
"response",
".",
"cache_control",
".",
"must_revalidate",
"=",
"True",
"response",
".",
"cache_control",
".",
"max_ag... | makes the provided response conditional based upon the request . | train | false |
12,791 | def register_assert_rewrite(*names):
for name in names:
if (not isinstance(name, str)):
msg = 'expected module names as *args, got {0} instead'
raise TypeError(msg.format(repr(names)))
for hook in sys.meta_path:
if isinstance(hook, rewrite.AssertionRewritingHook):
importhook = hook
break
else:
importhook = DummyRewriteHook()
importhook.mark_rewrite(*names)
| [
"def",
"register_assert_rewrite",
"(",
"*",
"names",
")",
":",
"for",
"name",
"in",
"names",
":",
"if",
"(",
"not",
"isinstance",
"(",
"name",
",",
"str",
")",
")",
":",
"msg",
"=",
"'expected module names as *args, got {0} instead'",
"raise",
"TypeError",
"("... | register one or more module names to be rewritten on import . | train | false |
12,792 | def onSelectAccountDBInterface(accountName):
return 'default'
| [
"def",
"onSelectAccountDBInterface",
"(",
"accountName",
")",
":",
"return",
"'default'"
] | kbengine method . | train | false |
12,793 | def LoadCheckFromFile(file_path, check_id, overwrite_if_exists=True):
configs = LoadConfigsFromFile(file_path)
conf = configs.get(check_id)
check = Check(**conf)
check.Validate()
CheckRegistry.RegisterCheck(check, source=('file:%s' % file_path), overwrite_if_exists=overwrite_if_exists)
logging.debug('Loaded check %s from %s', check.check_id, file_path)
return check
| [
"def",
"LoadCheckFromFile",
"(",
"file_path",
",",
"check_id",
",",
"overwrite_if_exists",
"=",
"True",
")",
":",
"configs",
"=",
"LoadConfigsFromFile",
"(",
"file_path",
")",
"conf",
"=",
"configs",
".",
"get",
"(",
"check_id",
")",
"check",
"=",
"Check",
"... | load a single check from a file . | train | true |
12,794 | @pytest.mark.parametrize('url1, url2', [('http://example.com', ''), ('', 'http://example.com')])
def test_same_domain_invalid_url(url1, url2):
with pytest.raises(urlutils.InvalidUrlError):
urlutils.same_domain(QUrl(url1), QUrl(url2))
| [
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'url1, url2'",
",",
"[",
"(",
"'http://example.com'",
",",
"''",
")",
",",
"(",
"''",
",",
"'http://example.com'",
")",
"]",
")",
"def",
"test_same_domain_invalid_url",
"(",
"url1",
",",
"url2",
")",
":... | test same_domain with invalid urls . | train | false |
12,795 | @register.tag
def permission_request_form(parser, token):
return PermissionFormNode.handle_token(parser, token, approved=False)
| [
"@",
"register",
".",
"tag",
"def",
"permission_request_form",
"(",
"parser",
",",
"token",
")",
":",
"return",
"PermissionFormNode",
".",
"handle_token",
"(",
"parser",
",",
"token",
",",
"approved",
"=",
"False",
")"
] | renders an "add permissions" form for the given object . | train | false |
12,797 | def convert_BooleanProperty(model, prop, kwargs):
return f.BooleanField(**kwargs)
| [
"def",
"convert_BooleanProperty",
"(",
"model",
",",
"prop",
",",
"kwargs",
")",
":",
"return",
"f",
".",
"BooleanField",
"(",
"**",
"kwargs",
")"
] | returns a form field for a db . | train | false |
12,798 | def grad_sum(x, y, z):
raise NotImplementedError('TODO: implement this function.')
| [
"def",
"grad_sum",
"(",
"x",
",",
"y",
",",
"z",
")",
":",
"raise",
"NotImplementedError",
"(",
"'TODO: implement this function.'",
")"
] | x: a theano variable y: a theano variable z: a theano expression involving x and y returns dz / dx + dz / dy . | train | false |
12,799 | def preserve_spaces(txt):
txt = re.sub('(?P<space>[ ]{2,})', (lambda mo: (' ' + (' ' * (len(mo.group('space')) - 1)))), txt)
txt = txt.replace(' DCTB ', ' ')
return txt
| [
"def",
"preserve_spaces",
"(",
"txt",
")",
":",
"txt",
"=",
"re",
".",
"sub",
"(",
"'(?P<space>[ ]{2,})'",
",",
"(",
"lambda",
"mo",
":",
"(",
"' '",
"+",
"(",
"' '",
"*",
"(",
"len",
"(",
"mo",
".",
"group",
"(",
"'space'",
")",
")",
"-",
"... | replaces spaces multiple spaces with entities . | train | false |
12,800 | def _is_valid_path(path, urlconf=None):
try:
urlresolvers.resolve(path, urlconf)
return True
except urlresolvers.Resolver404:
return False
| [
"def",
"_is_valid_path",
"(",
"path",
",",
"urlconf",
"=",
"None",
")",
":",
"try",
":",
"urlresolvers",
".",
"resolve",
"(",
"path",
",",
"urlconf",
")",
"return",
"True",
"except",
"urlresolvers",
".",
"Resolver404",
":",
"return",
"False"
] | returns true if the given path resolves against the default url resolver . | train | false |
12,801 | def extract_entities(template):
if ((template is None) or _RE_NONE_ENTITIES.search(template)):
return MATCH_ALL
extraction = _RE_GET_ENTITIES.findall(template)
if (len(extraction) > 0):
return list(set(extraction))
return MATCH_ALL
| [
"def",
"extract_entities",
"(",
"template",
")",
":",
"if",
"(",
"(",
"template",
"is",
"None",
")",
"or",
"_RE_NONE_ENTITIES",
".",
"search",
"(",
"template",
")",
")",
":",
"return",
"MATCH_ALL",
"extraction",
"=",
"_RE_GET_ENTITIES",
".",
"findall",
"(",
... | extract all entities for state_changed listener from template string . | train | false |
12,802 | def p_unary_expression_6(t):
pass
| [
"def",
"p_unary_expression_6",
"(",
"t",
")",
":",
"pass"
] | unary_expression : sizeof lparen type_name rparen . | train | false |
12,804 | def _create_char_spinner():
while True:
for c in '|/-\\':
(yield c)
| [
"def",
"_create_char_spinner",
"(",
")",
":",
"while",
"True",
":",
"for",
"c",
"in",
"'|/-\\\\'",
":",
"(",
"yield",
"c",
")"
] | creates a generator yielding a char based spinner . | train | false |
12,805 | def _setRandomEncoderResolution(minResolution=0.001):
encoder = model_params.MODEL_PARAMS['modelParams']['sensorParams']['encoders']['value']
if (encoder['type'] == 'RandomDistributedScalarEncoder'):
rangePadding = (abs((_INPUT_MAX - _INPUT_MIN)) * 0.2)
minValue = (_INPUT_MIN - rangePadding)
maxValue = (_INPUT_MAX + rangePadding)
resolution = max(minResolution, ((maxValue - minValue) / encoder.pop('numBuckets')))
encoder['resolution'] = resolution
| [
"def",
"_setRandomEncoderResolution",
"(",
"minResolution",
"=",
"0.001",
")",
":",
"encoder",
"=",
"model_params",
".",
"MODEL_PARAMS",
"[",
"'modelParams'",
"]",
"[",
"'sensorParams'",
"]",
"[",
"'encoders'",
"]",
"[",
"'value'",
"]",
"if",
"(",
"encoder",
"... | given model params . | train | true |
12,807 | def condor_stop(external_id):
failure_message = None
try:
check_call(('condor_rm', external_id))
except CalledProcessError:
failure_message = 'condor_rm failed'
except Exception as e:
('error encountered calling condor_rm: %s' % e)
return failure_message
| [
"def",
"condor_stop",
"(",
"external_id",
")",
":",
"failure_message",
"=",
"None",
"try",
":",
"check_call",
"(",
"(",
"'condor_rm'",
",",
"external_id",
")",
")",
"except",
"CalledProcessError",
":",
"failure_message",
"=",
"'condor_rm failed'",
"except",
"Excep... | stop running condor job and return a failure_message if this fails . | train | true |
12,808 | def mimedata_from_paths(paths):
abspaths = [core.abspath(path) for path in paths]
urls = [QtCore.QUrl.fromLocalFile(path) for path in abspaths]
mimedata = QtCore.QMimeData()
mimedata.setUrls(urls)
paths_text = core.list2cmdline(abspaths)
encoding = gitcfg.current().get(u'cola.dragencoding', u'utf-16')
moz_text = core.encode(paths_text, encoding=encoding)
mimedata.setData(u'text/x-moz-url', moz_text)
return mimedata
| [
"def",
"mimedata_from_paths",
"(",
"paths",
")",
":",
"abspaths",
"=",
"[",
"core",
".",
"abspath",
"(",
"path",
")",
"for",
"path",
"in",
"paths",
"]",
"urls",
"=",
"[",
"QtCore",
".",
"QUrl",
".",
"fromLocalFile",
"(",
"path",
")",
"for",
"path",
"... | return mimedata with a list of absolute path urls . | train | false |
12,809 | @click.command(u'reset-perms')
@pass_context
def reset_perms(context):
from frappe.permissions import reset_perms
for site in context.sites:
try:
frappe.init(site=site)
frappe.connect()
for d in frappe.db.sql_list(u'select name from `tabDocType`\n DCTB DCTB DCTB DCTB where istable=0 and custom=0'):
frappe.clear_cache(doctype=d)
reset_perms(d)
finally:
frappe.destroy()
| [
"@",
"click",
".",
"command",
"(",
"u'reset-perms'",
")",
"@",
"pass_context",
"def",
"reset_perms",
"(",
"context",
")",
":",
"from",
"frappe",
".",
"permissions",
"import",
"reset_perms",
"for",
"site",
"in",
"context",
".",
"sites",
":",
"try",
":",
"fr... | reset permissions for given doctype . | train | false |
12,810 | def treetypes(root):
w = NodeTypeWriter()
w.visit(root)
return u'\n'.join((([u''] + w.result) + [u'']))
| [
"def",
"treetypes",
"(",
"root",
")",
":",
"w",
"=",
"NodeTypeWriter",
"(",
")",
"w",
".",
"visit",
"(",
"root",
")",
"return",
"u'\\n'",
".",
"join",
"(",
"(",
"(",
"[",
"u''",
"]",
"+",
"w",
".",
"result",
")",
"+",
"[",
"u''",
"]",
")",
")... | returns a string representing the tree by class names . | train | false |
12,811 | def _quote_name(name):
return connection.ops.quote_name(name)
| [
"def",
"_quote_name",
"(",
"name",
")",
":",
"return",
"connection",
".",
"ops",
".",
"quote_name",
"(",
"name",
")"
] | shorthand for connection . | train | false |
12,812 | def _log_error_with_data(msg, post):
id = random.randint(0, 99999999)
msg = ('[%s] %s (dumping data)' % (id, msg))
paypal_log.error(msg)
logme = {'txn_id': post.get('txn_id'), 'txn_type': post.get('txn_type'), 'payer_email': post.get('payer_email'), 'receiver_email': post.get('receiver_email'), 'payment_status': post.get('payment_status'), 'payment_type': post.get('payment_type'), 'mc_gross': post.get('mc_gross'), 'item_number': post.get('item_number')}
paypal_log.error(('[%s] PayPal Data: %s' % (id, logme)))
| [
"def",
"_log_error_with_data",
"(",
"msg",
",",
"post",
")",
":",
"id",
"=",
"random",
".",
"randint",
"(",
"0",
",",
"99999999",
")",
"msg",
"=",
"(",
"'[%s] %s (dumping data)'",
"%",
"(",
"id",
",",
"msg",
")",
")",
"paypal_log",
".",
"error",
"(",
... | log a message along with some of the post info from paypal . | train | false |
12,813 | def rsa_sign(xml, ref_uri, private_key, password=None, cert=None, c14n_exc=True, sign_template=SIGN_REF_TMPL, key_info_template=KEY_INFO_RSA_TMPL):
ref_xml = canonicalize(xml, c14n_exc)
signed_info = (sign_template % {'ref_uri': ref_uri, 'digest_value': sha1_hash_digest(ref_xml)})
signed_info = canonicalize(signed_info, c14n_exc)
pkey = RSA.load_key(private_key, (lambda *args, **kwargs: password))
signature = pkey.sign(hashlib.sha1(signed_info).digest())
return {'ref_xml': ref_xml, 'ref_uri': ref_uri, 'signed_info': signed_info, 'signature_value': base64.b64encode(signature), 'key_info': key_info(pkey, cert, key_info_template)}
| [
"def",
"rsa_sign",
"(",
"xml",
",",
"ref_uri",
",",
"private_key",
",",
"password",
"=",
"None",
",",
"cert",
"=",
"None",
",",
"c14n_exc",
"=",
"True",
",",
"sign_template",
"=",
"SIGN_REF_TMPL",
",",
"key_info_template",
"=",
"KEY_INFO_RSA_TMPL",
")",
":",... | sign an xml document usign rsa . | train | false |
12,814 | def OutHeader1(text):
OutHeader(text, '=')
| [
"def",
"OutHeader1",
"(",
"text",
")",
":",
"OutHeader",
"(",
"text",
",",
"'='",
")"
] | output a level 1 header comment . | train | false |
12,816 | def _read_pfid_ed(fid):
out = {'comment_size': read_int32(fid), 'name': read_str(fid, 17)}
fid.seek(9, 1)
out.update({'pdf_number': read_int16(fid), 'total_events': read_int32(fid), 'timestamp': read_int32(fid), 'flags': read_int32(fid), 'de_process': read_int32(fid), 'checksum': read_int32(fid), 'ed_id': read_int32(fid), 'win_width': read_float(fid), 'win_offset': read_float(fid)})
fid.seek(8, 1)
return out
| [
"def",
"_read_pfid_ed",
"(",
"fid",
")",
":",
"out",
"=",
"{",
"'comment_size'",
":",
"read_int32",
"(",
"fid",
")",
",",
"'name'",
":",
"read_str",
"(",
"fid",
",",
"17",
")",
"}",
"fid",
".",
"seek",
"(",
"9",
",",
"1",
")",
"out",
".",
"update... | read pdf ed file . | train | false |
12,820 | def create_realistic_servicepair(test):
from_pool = StoragePool(reactor, create_zfs_pool(test), FilePath(test.mktemp()))
from_config = FilePath(test.mktemp())
from_service = VolumeService(from_config, from_pool, reactor=Clock())
from_service.startService()
test.addCleanup(from_service.stopService)
to_pool = StoragePool(reactor, create_zfs_pool(test), FilePath(test.mktemp()))
to_config = FilePath(test.mktemp())
to_service = VolumeService(to_config, to_pool, reactor=Clock())
to_service.startService()
test.addCleanup(to_service.stopService)
remote = RemoteVolumeManager(MutatingProcessNode(to_service), to_config)
origin_remote = LocalVolumeManager(from_service)
return ServicePair(from_service=from_service, to_service=to_service, remote=remote, origin_remote=origin_remote)
| [
"def",
"create_realistic_servicepair",
"(",
"test",
")",
":",
"from_pool",
"=",
"StoragePool",
"(",
"reactor",
",",
"create_zfs_pool",
"(",
"test",
")",
",",
"FilePath",
"(",
"test",
".",
"mktemp",
"(",
")",
")",
")",
"from_config",
"=",
"FilePath",
"(",
"... | create a servicepair that uses zfs for testing remotevolumemanager . | train | false |
12,821 | def receiver(signal, **kwargs):
def _decorator(func):
if isinstance(signal, (list, tuple)):
for s in signal:
s.connect(func, **kwargs)
else:
signal.connect(func, **kwargs)
return func
return _decorator
| [
"def",
"receiver",
"(",
"signal",
",",
"**",
"kwargs",
")",
":",
"def",
"_decorator",
"(",
"func",
")",
":",
"if",
"isinstance",
"(",
"signal",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"for",
"s",
"in",
"signal",
":",
"s",
".",
"connect",
"... | a decorator for connecting receivers to signals . | train | true |
12,823 | def atol(*args):
try:
s = args[0]
except IndexError:
raise TypeError(('function requires at least 1 argument: %d given' % len(args)))
if (type(s) == _StringType):
return _apply(_long, args)
else:
raise TypeError(('argument 1: expected string, %s found' % type(s).__name__))
| [
"def",
"atol",
"(",
"*",
"args",
")",
":",
"try",
":",
"s",
"=",
"args",
"[",
"0",
"]",
"except",
"IndexError",
":",
"raise",
"TypeError",
"(",
"(",
"'function requires at least 1 argument: %d given'",
"%",
"len",
"(",
"args",
")",
")",
")",
"if",
"(",
... | atol -> long return the long integer represented by the string s in the given base . | train | false |
12,824 | def generate_mtime_map(opts, path_map):
file_map = {}
for (saltenv, path_list) in six.iteritems(path_map):
for path in path_list:
for (directory, dirnames, filenames) in os.walk(path):
dirnames[:] = [d for d in dirnames if (not is_file_ignored(opts, d))]
for item in filenames:
try:
file_path = os.path.join(directory, item)
file_map[file_path] = os.path.getmtime(file_path)
except (OSError, IOError):
log.info('Failed to get mtime on {0}, dangling symlink ?'.format(file_path))
continue
return file_map
| [
"def",
"generate_mtime_map",
"(",
"opts",
",",
"path_map",
")",
":",
"file_map",
"=",
"{",
"}",
"for",
"(",
"saltenv",
",",
"path_list",
")",
"in",
"six",
".",
"iteritems",
"(",
"path_map",
")",
":",
"for",
"path",
"in",
"path_list",
":",
"for",
"(",
... | generate a dict of filename -> mtime . | train | false |
12,825 | def test_replace_tuple():
replaced = replace_hy_obj((long_type(0),), HyInteger(13))
assert (type(replaced) == HyList)
assert (type(replaced[0]) == HyInteger)
assert (replaced == HyList([HyInteger(0)]))
| [
"def",
"test_replace_tuple",
"(",
")",
":",
"replaced",
"=",
"replace_hy_obj",
"(",
"(",
"long_type",
"(",
"0",
")",
",",
")",
",",
"HyInteger",
"(",
"13",
")",
")",
"assert",
"(",
"type",
"(",
"replaced",
")",
"==",
"HyList",
")",
"assert",
"(",
"ty... | test replacing tuples . | train | false |
12,826 | def _get_count(queryset):
try:
return queryset.count()
except (AttributeError, TypeError):
return len(queryset)
| [
"def",
"_get_count",
"(",
"queryset",
")",
":",
"try",
":",
"return",
"queryset",
".",
"count",
"(",
")",
"except",
"(",
"AttributeError",
",",
"TypeError",
")",
":",
"return",
"len",
"(",
"queryset",
")"
] | determine an object count . | train | false |
12,827 | def read_cache_entry(f):
beginoffset = f.tell()
ctime = read_cache_time(f)
mtime = read_cache_time(f)
(dev, ino, mode, uid, gid, size, sha, flags) = struct.unpack('>LLLLLL20sH', f.read(((20 + (4 * 6)) + 2)))
name = f.read((flags & 4095))
real_size = (((f.tell() - beginoffset) + 8) & (~ 7))
f.read(((beginoffset + real_size) - f.tell()))
return (name, ctime, mtime, dev, ino, mode, uid, gid, size, sha_to_hex(sha), (flags & (~ 4095)))
| [
"def",
"read_cache_entry",
"(",
"f",
")",
":",
"beginoffset",
"=",
"f",
".",
"tell",
"(",
")",
"ctime",
"=",
"read_cache_time",
"(",
"f",
")",
"mtime",
"=",
"read_cache_time",
"(",
"f",
")",
"(",
"dev",
",",
"ino",
",",
"mode",
",",
"uid",
",",
"gi... | read an entry from a cache file . | train | false |
12,829 | def _cast_params_from(params, context, schemas):
result = {}
for name in params:
param_schema = {}
for schema in schemas:
if (name in schema):
param_schema = schema[name]
result[name] = _cast(context[name], param_schema)
return result
| [
"def",
"_cast_params_from",
"(",
"params",
",",
"context",
",",
"schemas",
")",
":",
"result",
"=",
"{",
"}",
"for",
"name",
"in",
"params",
":",
"param_schema",
"=",
"{",
"}",
"for",
"schema",
"in",
"schemas",
":",
"if",
"(",
"name",
"in",
"schema",
... | pick a list of parameters from context and cast each of them according to the schemas provided . | train | false |
12,833 | def flat_user_answer(user_answer):
def parse_user_answer(answer):
key = answer.keys()[0]
value = answer.values()[0]
if isinstance(value, dict):
complex_value_list = []
v_value = value
while isinstance(v_value, dict):
v_key = v_value.keys()[0]
v_value = v_value.values()[0]
complex_value_list.append(v_key)
complex_value = '{0}'.format(v_value)
for i in reversed(complex_value_list):
complex_value = '{0}[{1}]'.format(complex_value, i)
res = {key: complex_value}
return res
else:
return answer
result = []
for answer in user_answer:
parse_answer = parse_user_answer(answer)
result.append(parse_answer)
return result
| [
"def",
"flat_user_answer",
"(",
"user_answer",
")",
":",
"def",
"parse_user_answer",
"(",
"answer",
")",
":",
"key",
"=",
"answer",
".",
"keys",
"(",
")",
"[",
"0",
"]",
"value",
"=",
"answer",
".",
"values",
"(",
")",
"[",
"0",
"]",
"if",
"isinstanc... | convert nested user_answer to flat format . | train | false |
12,836 | def closed_issue(issue, after=None):
if (issue['state'] == 'closed'):
if ((after is None) or (parse_timestamp(issue['closed_at']) > after)):
return True
return False
| [
"def",
"closed_issue",
"(",
"issue",
",",
"after",
"=",
"None",
")",
":",
"if",
"(",
"issue",
"[",
"'state'",
"]",
"==",
"'closed'",
")",
":",
"if",
"(",
"(",
"after",
"is",
"None",
")",
"or",
"(",
"parse_timestamp",
"(",
"issue",
"[",
"'closed_at'",... | returns true iff this issue was closed after given date . | train | true |
12,837 | def segment(sequence, aliases):
if (not (sequence or aliases)):
return
for (alias, parts) in aliases.items():
variants = {alias: OrderByTuple(parts), OrderBy(alias).opposite: OrderByTuple(parts).opposite}
for (valias, vparts) in variants.items():
if (list(sequence[:len(vparts)]) == list(vparts)):
tail_aliases = dict(aliases)
del tail_aliases[alias]
tail_sequence = sequence[len(vparts):]
if tail_sequence:
for tail in segment(tail_sequence, tail_aliases):
(yield tuple(chain([valias], tail)))
else:
continue
else:
(yield tuple([valias]))
| [
"def",
"segment",
"(",
"sequence",
",",
"aliases",
")",
":",
"if",
"(",
"not",
"(",
"sequence",
"or",
"aliases",
")",
")",
":",
"return",
"for",
"(",
"alias",
",",
"parts",
")",
"in",
"aliases",
".",
"items",
"(",
")",
":",
"variants",
"=",
"{",
... | translates a flat sequence of items into a set of prefixed aliases . | train | false |
12,838 | def pretty_use_unicode(flag=None):
global _use_unicode
global unicode_warnings
if (flag is None):
return _use_unicode
if unicode_warnings:
known = [('LATIN SUBSCRIPT SMALL LETTER %s' % i) for i in 'HKLMNPST']
unicode_warnings = '\n'.join([l for l in unicode_warnings.splitlines() if (not any(((i in l) for i in known)))])
if (flag and unicode_warnings):
warnings.warn(unicode_warnings)
unicode_warnings = ''
use_unicode_prev = _use_unicode
_use_unicode = flag
return use_unicode_prev
| [
"def",
"pretty_use_unicode",
"(",
"flag",
"=",
"None",
")",
":",
"global",
"_use_unicode",
"global",
"unicode_warnings",
"if",
"(",
"flag",
"is",
"None",
")",
":",
"return",
"_use_unicode",
"if",
"unicode_warnings",
":",
"known",
"=",
"[",
"(",
"'LATIN SUBSCRI... | set whether pretty-printer should use unicode by default . | train | false |
12,839 | def None2NULL(o, d):
return NULL
| [
"def",
"None2NULL",
"(",
"o",
",",
"d",
")",
":",
"return",
"NULL"
] | convert none to null . | train | false |
12,840 | def add_channel_arguments(parser):
parser.add_argument('--repo-data', dest='repo_data', default=None, help='Published repository data (will be fetched from --channel if not available and written). Defaults to [channel_name]-repodata.json.')
parser.add_argument('--diff-hours', dest='diff_hours', default='25', help='If finding all recently changed recipes, use this number of hours.')
parser.add_argument('--recipes-dir', dest='recipes_dir', default='./bioconda-recipes')
| [
"def",
"add_channel_arguments",
"(",
"parser",
")",
":",
"parser",
".",
"add_argument",
"(",
"'--repo-data'",
",",
"dest",
"=",
"'repo_data'",
",",
"default",
"=",
"None",
",",
"help",
"=",
"'Published repository data (will be fetched from --channel if not available and w... | add arguments only used if running mulled over a whole conda channel . | train | false |
12,841 | @contextlib.contextmanager
def obj_target_cell(obj, cell):
with try_target_cell(obj._context, cell) as target:
with obj.obj_alternate_context(target):
(yield)
| [
"@",
"contextlib",
".",
"contextmanager",
"def",
"obj_target_cell",
"(",
"obj",
",",
"cell",
")",
":",
"with",
"try_target_cell",
"(",
"obj",
".",
"_context",
",",
"cell",
")",
"as",
"target",
":",
"with",
"obj",
".",
"obj_alternate_context",
"(",
"target",
... | run with objects context set to a specific cell . | train | false |
12,842 | def _list_certs(certificatestore='My'):
ret = dict()
pscmd = list()
blacklist_keys = ['DnsNameList', 'Thumbprint']
cert_path = 'Cert:\\LocalMachine\\{0}'.format(certificatestore)
pscmd.append("Get-ChildItem -Path '{0}' | Select-Object".format(cert_path))
pscmd.append(' DnsNameList, SerialNumber, Subject, Thumbprint, Version')
cmd_ret = _srvmgr(func=str().join(pscmd), as_json=True)
try:
items = json.loads(cmd_ret['stdout'], strict=False)
except ValueError:
_LOG.error('Unable to parse return data as Json.')
for item in items:
cert_info = dict()
for key in item:
if (key not in blacklist_keys):
cert_info[key.lower()] = item[key]
cert_info['dnsnames'] = [name['Unicode'] for name in item['DnsNameList']]
ret[item['Thumbprint']] = cert_info
return ret
| [
"def",
"_list_certs",
"(",
"certificatestore",
"=",
"'My'",
")",
":",
"ret",
"=",
"dict",
"(",
")",
"pscmd",
"=",
"list",
"(",
")",
"blacklist_keys",
"=",
"[",
"'DnsNameList'",
",",
"'Thumbprint'",
"]",
"cert_path",
"=",
"'Cert:\\\\LocalMachine\\\\{0}'",
".",
... | list details of available certificates . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.