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 |
|---|---|---|---|---|---|
7,411 | def _escalation_rules_to_string(escalation_rules):
result = ''
for rule in escalation_rules:
result += 'escalation_delay_in_minutes: {0} '.format(rule['escalation_delay_in_minutes'])
for target in rule['targets']:
result += '{0}:{1} '.format(target['type'], target['id'])
return result
| [
"def",
"_escalation_rules_to_string",
"(",
"escalation_rules",
")",
":",
"result",
"=",
"''",
"for",
"rule",
"in",
"escalation_rules",
":",
"result",
"+=",
"'escalation_delay_in_minutes: {0} '",
".",
"format",
"(",
"rule",
"[",
"'escalation_delay_in_minutes'",
"]",
")... | convert escalation_rules dict to a string for comparison . | train | true |
7,412 | def start_tag(doc, name, attr=None, body=None, namespace=None):
if (attr is None):
attr = {}
attr_vals = {}
attr_keys = {}
for (key, val) in attr.items():
key_tuple = (namespace, key)
attr_vals[key_tuple] = val
attr_keys[key_tuple] = key
attr2 = AttributesNSImpl(attr_vals, attr_keys)
doc.startElementNS((namespace, name), name, attr2)
if body:
doc.characters(body)
| [
"def",
"start_tag",
"(",
"doc",
",",
"name",
",",
"attr",
"=",
"None",
",",
"body",
"=",
"None",
",",
"namespace",
"=",
"None",
")",
":",
"if",
"(",
"attr",
"is",
"None",
")",
":",
"attr",
"=",
"{",
"}",
"attr_vals",
"=",
"{",
"}",
"attr_keys",
... | the text representation of the start tag for a tag . | train | false |
7,413 | def CheckCommaSpacing(filename, clean_lines, linenum, error):
raw = clean_lines.lines_without_raw_strings
line = clean_lines.elided[linenum]
if (Search(',[^,\\s]', ReplaceAll('\\boperator\\s*,\\s*\\(', 'F(', line)) and Search(',[^,\\s]', raw[linenum])):
error(filename, linenum, 'whitespace/comma', 3, 'Missing space after ,')
if Search(';[^\\s};\\\\)/]', line):
error(filename, linenum, 'whitespace/semicolon', 3, 'Missing space after ;')
| [
"def",
"CheckCommaSpacing",
"(",
"filename",
",",
"clean_lines",
",",
"linenum",
",",
"error",
")",
":",
"raw",
"=",
"clean_lines",
".",
"lines_without_raw_strings",
"line",
"=",
"clean_lines",
".",
"elided",
"[",
"linenum",
"]",
"if",
"(",
"Search",
"(",
"'... | checks for horizontal spacing near commas and semicolons . | train | false |
7,414 | def getNewRepository():
return ExportRepository()
| [
"def",
"getNewRepository",
"(",
")",
":",
"return",
"ExportRepository",
"(",
")"
] | get the repository constructor . | train | false |
7,415 | def run_one_command(*args):
cmd_line = (('"' + executable) + '" '.join(args))
(inp, out, err) = os.popen3(cmd_line)
print cmd_line
(output, err) = multireader(out, err)
res = out.close()
if res:
print ('%d running %s failed' % (res, cmd_line))
print 'output was', output
print 'err', err
return (output, err, res)
| [
"def",
"run_one_command",
"(",
"*",
"args",
")",
":",
"cmd_line",
"=",
"(",
"(",
"'\"'",
"+",
"executable",
")",
"+",
"'\" '",
".",
"join",
"(",
"args",
")",
")",
"(",
"inp",
",",
"out",
",",
"err",
")",
"=",
"os",
".",
"popen3",
"(",
"cmd_line",... | runs a single command . | train | false |
7,416 | def _send_new_pending_email(instance):
context = {'approval_url': urlunsplit((('https' if (settings.HTTPS == 'on') else 'http'), instance.site.domain, reverse('admin:api_admin_apiaccessrequest_change', args=(instance.id,)), '', '')), 'api_request': instance}
message = render_to_string('api_admin/api_access_request_email_new_request.txt', context)
try:
send_mail(_('API access request from {company}').format(company=instance.company_name), message, settings.API_ACCESS_FROM_EMAIL, [settings.API_ACCESS_MANAGER_EMAIL], fail_silently=False)
except SMTPException:
log.exception('Error sending API user notification email for request [%s].', instance.id)
| [
"def",
"_send_new_pending_email",
"(",
"instance",
")",
":",
"context",
"=",
"{",
"'approval_url'",
":",
"urlunsplit",
"(",
"(",
"(",
"'https'",
"if",
"(",
"settings",
".",
"HTTPS",
"==",
"'on'",
")",
"else",
"'http'",
")",
",",
"instance",
".",
"site",
... | send an email to settings . | train | false |
7,418 | def get_oauth_keys(provider):
keys = frappe.conf.get(u'{provider}_login'.format(provider=provider))
if (not keys):
social = frappe.get_doc(u'Social Login Keys', u'Social Login Keys')
keys = {}
for fieldname in (u'client_id', u'client_secret'):
value = social.get(u'{provider}_{fieldname}'.format(provider=provider, fieldname=fieldname))
if (not value):
keys = {}
break
keys[fieldname] = value
return keys
else:
return {u'client_id': keys[u'client_id'], u'client_secret': keys[u'client_secret']}
| [
"def",
"get_oauth_keys",
"(",
"provider",
")",
":",
"keys",
"=",
"frappe",
".",
"conf",
".",
"get",
"(",
"u'{provider}_login'",
".",
"format",
"(",
"provider",
"=",
"provider",
")",
")",
"if",
"(",
"not",
"keys",
")",
":",
"social",
"=",
"frappe",
".",... | get client_id and client_secret from database or conf . | train | false |
7,420 | def delete_collection(committer_id, collection_id, force_deletion=False):
collection_rights_model = collection_models.CollectionRightsModel.get(collection_id)
collection_rights_model.delete(committer_id, '', force_deletion=force_deletion)
collection_model = collection_models.CollectionModel.get(collection_id)
collection_model.delete(committer_id, feconf.COMMIT_MESSAGE_COLLECTION_DELETED, force_deletion=force_deletion)
collection_memcache_key = _get_collection_memcache_key(collection_id)
memcache_services.delete(collection_memcache_key)
delete_documents_from_search_index([collection_id])
delete_collection_summary(collection_id)
activity_services.remove_featured_activity(feconf.ACTIVITY_TYPE_COLLECTION, collection_id)
| [
"def",
"delete_collection",
"(",
"committer_id",
",",
"collection_id",
",",
"force_deletion",
"=",
"False",
")",
":",
"collection_rights_model",
"=",
"collection_models",
".",
"CollectionRightsModel",
".",
"get",
"(",
"collection_id",
")",
"collection_rights_model",
"."... | deletes the collection with the given collection_id . | train | false |
7,421 | def simple_read_words(filename='nietzsche.txt'):
with open('nietzsche.txt', 'r') as f:
words = f.read()
return words
| [
"def",
"simple_read_words",
"(",
"filename",
"=",
"'nietzsche.txt'",
")",
":",
"with",
"open",
"(",
"'nietzsche.txt'",
",",
"'r'",
")",
"as",
"f",
":",
"words",
"=",
"f",
".",
"read",
"(",
")",
"return",
"words"
] | read context from file without any preprocessing . | train | false |
7,422 | def generate_include_search_paths(hdr, extra_dirs):
if (os.sep in hdr):
paths = [hdr]
else:
arg_paths = itertools.chain(COMMON_HEADER_PATHS, extra_dirs)
search_paths = unique_not_false_list(arg_paths)
paths = path_joiner(hdr, search_paths)
return paths
| [
"def",
"generate_include_search_paths",
"(",
"hdr",
",",
"extra_dirs",
")",
":",
"if",
"(",
"os",
".",
"sep",
"in",
"hdr",
")",
":",
"paths",
"=",
"[",
"hdr",
"]",
"else",
":",
"arg_paths",
"=",
"itertools",
".",
"chain",
"(",
"COMMON_HEADER_PATHS",
",",... | generate full paths of potential locations of a given header file based on common_header_paths . | train | false |
7,424 | def make_member_list(members, **attr_map):
def _fetch_memb(memb, attr_map):
return dict([(k, memb[v]) for (k, v) in attr_map.items() if (v in memb.keys())])
return [_fetch_memb(memb, attr_map) for memb in members]
| [
"def",
"make_member_list",
"(",
"members",
",",
"**",
"attr_map",
")",
":",
"def",
"_fetch_memb",
"(",
"memb",
",",
"attr_map",
")",
":",
"return",
"dict",
"(",
"[",
"(",
"k",
",",
"memb",
"[",
"v",
"]",
")",
"for",
"(",
"k",
",",
"v",
")",
"in",... | create a dict representation of a list of members which we can use to serialize the members list . | train | false |
7,425 | def list_from_child_node(xpath, suppress_blank=False):
def list_from_child_node_lambda(unused_value, bulkload_state):
result = []
for node in bulkload_state.current_dictionary['__node__'].findall(xpath):
if node.text:
result.append(node.text)
elif (not suppress_blank):
result.append('')
return result
return list_from_child_node_lambda
| [
"def",
"list_from_child_node",
"(",
"xpath",
",",
"suppress_blank",
"=",
"False",
")",
":",
"def",
"list_from_child_node_lambda",
"(",
"unused_value",
",",
"bulkload_state",
")",
":",
"result",
"=",
"[",
"]",
"for",
"node",
"in",
"bulkload_state",
".",
"current_... | return a list property from child nodes of the current xml node . | train | false |
7,426 | def _validate_api_params(params):
return (isinstance(params['api_page_id'], (six.string_types, six.text_type)) and isinstance(params['api_key'], (six.string_types, six.text_type)))
| [
"def",
"_validate_api_params",
"(",
"params",
")",
":",
"return",
"(",
"isinstance",
"(",
"params",
"[",
"'api_page_id'",
"]",
",",
"(",
"six",
".",
"string_types",
",",
"six",
".",
"text_type",
")",
")",
"and",
"isinstance",
"(",
"params",
"[",
"'api_key'... | validate the api params as specified in the config file . | train | true |
7,427 | def release():
return uname()[2]
| [
"def",
"release",
"(",
")",
":",
"return",
"uname",
"(",
")",
"[",
"2",
"]"
] | release a collection of hosts from user its ok if user does not own these systems . | train | false |
7,428 | def _to_volume_name(dataset_id):
return VolumeName(namespace=u'default', dataset_id=dataset_id)
| [
"def",
"_to_volume_name",
"(",
"dataset_id",
")",
":",
"return",
"VolumeName",
"(",
"namespace",
"=",
"u'default'",
",",
"dataset_id",
"=",
"dataset_id",
")"
] | convert dataset id to volumename with u"default" namespace . | train | false |
7,429 | def banner():
_ = BANNER
if (not getattr(LOGGER_HANDLER, 'is_tty', False)):
_ = re.sub('\x1b.+?m', '', _)
dataToStdout(_, forceOutput=True)
| [
"def",
"banner",
"(",
")",
":",
"_",
"=",
"BANNER",
"if",
"(",
"not",
"getattr",
"(",
"LOGGER_HANDLER",
",",
"'is_tty'",
",",
"False",
")",
")",
":",
"_",
"=",
"re",
".",
"sub",
"(",
"'\\x1b.+?m'",
",",
"''",
",",
"_",
")",
"dataToStdout",
"(",
"... | function prints pocsuite banner with its version . | train | false |
7,430 | def params_to_strings(params, param_values, app):
rval = dict()
for (key, value) in param_values.items():
if (key in params):
value = params[key].value_to_basic(value, app)
rval[key] = str(dumps(value))
return rval
| [
"def",
"params_to_strings",
"(",
"params",
",",
"param_values",
",",
"app",
")",
":",
"rval",
"=",
"dict",
"(",
")",
"for",
"(",
"key",
",",
"value",
")",
"in",
"param_values",
".",
"items",
"(",
")",
":",
"if",
"(",
"key",
"in",
"params",
")",
":"... | convert a dictionary of parameter values to a dictionary of strings suitable for persisting . | train | false |
7,431 | def is_kernel_thread(proc):
try:
return (os.getpgid(proc.pid) == 0)
except OSError:
return False
| [
"def",
"is_kernel_thread",
"(",
"proc",
")",
":",
"try",
":",
"return",
"(",
"os",
".",
"getpgid",
"(",
"proc",
".",
"pid",
")",
"==",
"0",
")",
"except",
"OSError",
":",
"return",
"False"
] | return true if proc is a kernel thread . | train | false |
7,432 | def is_old_code():
code_exists = exists('~/viewfinder')
if (not code_exists):
return False
with settings(warn_only=True):
is_link = run('readlink ~/viewfinder')
if (is_link.return_code == 0):
return False
return True
| [
"def",
"is_old_code",
"(",
")",
":",
"code_exists",
"=",
"exists",
"(",
"'~/viewfinder'",
")",
"if",
"(",
"not",
"code_exists",
")",
":",
"return",
"False",
"with",
"settings",
"(",
"warn_only",
"=",
"True",
")",
":",
"is_link",
"=",
"run",
"(",
"'readli... | return true if ~/viewfinder is old-style or false if new style . | train | false |
7,433 | def parse_time_string(arg, freq=None, dayfirst=None, yearfirst=None):
from pandas.core.config import get_option
if (not isinstance(arg, compat.string_types)):
return arg
from pandas.tseries.offsets import DateOffset
if isinstance(freq, DateOffset):
freq = freq.rule_code
if (dayfirst is None):
dayfirst = get_option('display.date_dayfirst')
if (yearfirst is None):
yearfirst = get_option('display.date_yearfirst')
return tslib.parse_datetime_string_with_reso(arg, freq=freq, dayfirst=dayfirst, yearfirst=yearfirst)
| [
"def",
"parse_time_string",
"(",
"arg",
",",
"freq",
"=",
"None",
",",
"dayfirst",
"=",
"None",
",",
"yearfirst",
"=",
"None",
")",
":",
"from",
"pandas",
".",
"core",
".",
"config",
"import",
"get_option",
"if",
"(",
"not",
"isinstance",
"(",
"arg",
"... | try hard to parse datetime string . | train | false |
7,434 | def instance_uri(request, resource_name, **params):
return strip_uri_prefix(request.route_path(('%s-record' % resource_name), **params))
| [
"def",
"instance_uri",
"(",
"request",
",",
"resource_name",
",",
"**",
"params",
")",
":",
"return",
"strip_uri_prefix",
"(",
"request",
".",
"route_path",
"(",
"(",
"'%s-record'",
"%",
"resource_name",
")",
",",
"**",
"params",
")",
")"
] | return the uri for the given resource . | train | false |
7,436 | def warn_cxx(val):
if ((sys.platform == 'darwin') and ('clang++' not in val)):
_logger.warning('Only clang++ is supported. With g++, we end up with strange g++/OSX bugs.')
return True
| [
"def",
"warn_cxx",
"(",
"val",
")",
":",
"if",
"(",
"(",
"sys",
".",
"platform",
"==",
"'darwin'",
")",
"and",
"(",
"'clang++'",
"not",
"in",
"val",
")",
")",
":",
"_logger",
".",
"warning",
"(",
"'Only clang++ is supported. With g++, we end up with strange g+... | we only support clang++ as otherwise we hit strange g++/osx bugs . | train | false |
7,437 | def _visible_fields(user_profile, user, configuration=None):
if (not configuration):
configuration = settings.ACCOUNT_VISIBILITY_CONFIGURATION
profile_visibility = get_profile_visibility(user_profile, user, configuration)
if (profile_visibility == ALL_USERS_VISIBILITY):
return configuration.get('shareable_fields')
else:
return configuration.get('public_fields')
| [
"def",
"_visible_fields",
"(",
"user_profile",
",",
"user",
",",
"configuration",
"=",
"None",
")",
":",
"if",
"(",
"not",
"configuration",
")",
":",
"configuration",
"=",
"settings",
".",
"ACCOUNT_VISIBILITY_CONFIGURATION",
"profile_visibility",
"=",
"get_profile_v... | return what fields should be visible based on user settings . | train | false |
7,438 | def CreateCookieData(email, admin):
nickname = email.split('@')[0]
if admin:
app_list = os.environ['APPLICATION_ID']
else:
app_list = ''
secret = os.environ['COOKIE_SECRET']
hashed = sha.new((((email + nickname) + app_list) + secret)).hexdigest()
return urllib.quote_plus('{0}:{1}:{2}:{3}'.format(email, nickname, app_list, hashed))
| [
"def",
"CreateCookieData",
"(",
"email",
",",
"admin",
")",
":",
"nickname",
"=",
"email",
".",
"split",
"(",
"'@'",
")",
"[",
"0",
"]",
"if",
"admin",
":",
"app_list",
"=",
"os",
".",
"environ",
"[",
"'APPLICATION_ID'",
"]",
"else",
":",
"app_list",
... | creates cookie payload data . | train | false |
7,439 | def _GetSupportedApiVersions(versions, runtime):
if ('supported_api_versions' in versions):
return versions['supported_api_versions'].get(runtime, versions)['api_versions']
return versions['api_versions']
| [
"def",
"_GetSupportedApiVersions",
"(",
"versions",
",",
"runtime",
")",
":",
"if",
"(",
"'supported_api_versions'",
"in",
"versions",
")",
":",
"return",
"versions",
"[",
"'supported_api_versions'",
"]",
".",
"get",
"(",
"runtime",
",",
"versions",
")",
"[",
... | returns the runtime-specific or general list of supported runtimes . | train | false |
7,440 | def rtrimTerminus(command, terminator=None):
if terminator:
pieces = command.split(terminator)
if (len(pieces) > 1):
command = (terminator.join(pieces[:(-1)]) + terminator)
return command
| [
"def",
"rtrimTerminus",
"(",
"command",
",",
"terminator",
"=",
"None",
")",
":",
"if",
"terminator",
":",
"pieces",
"=",
"command",
".",
"split",
"(",
"terminator",
")",
"if",
"(",
"len",
"(",
"pieces",
")",
">",
"1",
")",
":",
"command",
"=",
"(",
... | return command minus anything that follows the final terminator . | train | false |
7,444 | def signed_serialize(data, secret):
pickled = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
try:
secret = bytes_(secret)
except UnicodeEncodeError:
secret = bytes_(secret, 'utf-8')
sig = hmac.new(secret, pickled, hashlib.sha1).hexdigest()
return (sig + native_(base64.b64encode(pickled)))
| [
"def",
"signed_serialize",
"(",
"data",
",",
"secret",
")",
":",
"pickled",
"=",
"pickle",
".",
"dumps",
"(",
"data",
",",
"pickle",
".",
"HIGHEST_PROTOCOL",
")",
"try",
":",
"secret",
"=",
"bytes_",
"(",
"secret",
")",
"except",
"UnicodeEncodeError",
":",... | serialize any pickleable structure and sign it using the secret . | train | false |
7,445 | def getInsetLoopsFromLoop(loop, radius, thresholdRatio=0.9):
if (radius == 0.0):
return [loop]
isInset = (radius > 0)
insetLoops = []
isLoopWiddershins = euclidean.isWiddershins(loop)
arounds = getAroundsFromLoop(loop, radius, thresholdRatio)
for around in arounds:
leftPoint = euclidean.getLeftPoint(around)
shouldBeWithin = (isInset == isLoopWiddershins)
if (euclidean.isPointInsideLoop(loop, leftPoint) == shouldBeWithin):
if (isLoopWiddershins != euclidean.isWiddershins(around)):
around.reverse()
insetLoops.append(around)
return insetLoops
| [
"def",
"getInsetLoopsFromLoop",
"(",
"loop",
",",
"radius",
",",
"thresholdRatio",
"=",
"0.9",
")",
":",
"if",
"(",
"radius",
"==",
"0.0",
")",
":",
"return",
"[",
"loop",
"]",
"isInset",
"=",
"(",
"radius",
">",
"0",
")",
"insetLoops",
"=",
"[",
"]"... | get the inset loops . | train | false |
7,446 | def getNewRepository():
return ExportRepository()
| [
"def",
"getNewRepository",
"(",
")",
":",
"return",
"ExportRepository",
"(",
")"
] | get the repository constructor . | train | false |
7,447 | def getargspecfromtext(text):
blocks = text.split('\n\n')
first_block = blocks[0].strip()
return getsignaturefromtext(first_block, '')
| [
"def",
"getargspecfromtext",
"(",
"text",
")",
":",
"blocks",
"=",
"text",
".",
"split",
"(",
"'\\n\\n'",
")",
"first_block",
"=",
"blocks",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"return",
"getsignaturefromtext",
"(",
"first_block",
",",
"''",
")"
] | try to get the formatted argspec of a callable from the first block of its docstring this will return something like . | train | true |
7,449 | def _is_valid_sub_path(path, parent_paths):
if (not parent_paths):
return True
for parent_path in parent_paths:
if (path[:len(parent_path)] == parent_path):
return True
return False
| [
"def",
"_is_valid_sub_path",
"(",
"path",
",",
"parent_paths",
")",
":",
"if",
"(",
"not",
"parent_paths",
")",
":",
"return",
"True",
"for",
"parent_path",
"in",
"parent_paths",
":",
"if",
"(",
"path",
"[",
":",
"len",
"(",
"parent_path",
")",
"]",
"=="... | check if a sub path is valid given an iterable of parent paths . | train | false |
7,450 | def sort_against(list1, list2, reverse=False):
try:
return [item for (_, item) in sorted(zip(list2, list1), key=(lambda x: x[0]), reverse=reverse)]
except:
return list1
| [
"def",
"sort_against",
"(",
"list1",
",",
"list2",
",",
"reverse",
"=",
"False",
")",
":",
"try",
":",
"return",
"[",
"item",
"for",
"(",
"_",
",",
"item",
")",
"in",
"sorted",
"(",
"zip",
"(",
"list2",
",",
"list1",
")",
",",
"key",
"=",
"(",
... | arrange items of list1 in the same order as sorted . | train | true |
7,452 | def post_delete_site(instance, sender, **kwargs):
SiteResources.objects.filter(site=instance).delete()
SitePeople.objects.filter(site=instance).delete()
| [
"def",
"post_delete_site",
"(",
"instance",
",",
"sender",
",",
"**",
"kwargs",
")",
":",
"SiteResources",
".",
"objects",
".",
"filter",
"(",
"site",
"=",
"instance",
")",
".",
"delete",
"(",
")",
"SitePeople",
".",
"objects",
".",
"filter",
"(",
"site"... | signal to delete the siteresources on site delete . | train | false |
7,453 | def download_encrypted_blob(bucket_name, source_blob_name, destination_file_name, base64_encryption_key):
storage_client = storage.Client()
bucket = storage_client.get_bucket(bucket_name)
encryption_key = base64.b64decode(base64_encryption_key)
blob = Blob(source_blob_name, bucket, encryption_key=encryption_key)
blob.download_to_filename(destination_file_name)
print 'Blob {} downloaded to {}.'.format(source_blob_name, destination_file_name)
| [
"def",
"download_encrypted_blob",
"(",
"bucket_name",
",",
"source_blob_name",
",",
"destination_file_name",
",",
"base64_encryption_key",
")",
":",
"storage_client",
"=",
"storage",
".",
"Client",
"(",
")",
"bucket",
"=",
"storage_client",
".",
"get_bucket",
"(",
"... | downloads a previously-encrypted blob from google cloud storage . | train | false |
7,454 | def _doc_components_from_url(url, required_locale=None, check_host=True):
parsed = urlparse(url)
if (check_host and parsed.netloc):
return False
(locale, path) = split_path(parsed.path)
if (required_locale and (locale != required_locale)):
return False
path = ('/' + path)
try:
(view, view_args, view_kwargs) = resolve(path)
except Http404:
return False
import kitsune.wiki.views
if (view != kitsune.wiki.views.document):
raise _NotDocumentView
return (locale, path, view_kwargs['document_slug'])
| [
"def",
"_doc_components_from_url",
"(",
"url",
",",
"required_locale",
"=",
"None",
",",
"check_host",
"=",
"True",
")",
":",
"parsed",
"=",
"urlparse",
"(",
"url",
")",
"if",
"(",
"check_host",
"and",
"parsed",
".",
"netloc",
")",
":",
"return",
"False",
... | return if url is a document . | train | false |
7,457 | def clear_bad_addresses(store):
bad_tx = ['a288fec5559c3f73fd3d93db8e8460562ebfe2fcf04a5114e8d0f2920a6270dc', '2a0597e665ac3d1cabeede95cedf907934db7f639e477b3c77b242140d8cf728', 'e411dbebd2f7d64dafeef9b14b5c59ec60c36779d43f850e5e347abee1e1a455']
for tx_hash in bad_tx:
row = store.selectrow('\n SELECT tx_id FROM tx WHERE tx_hash = ?', (store.hashin_hex(tx_hash),))
if row:
store.sql('\n UPDATE txout SET pubkey_id = NULL\n WHERE tx_id = ? AND txout_pos = 1 AND pubkey_id IS NOT NULL', (row[0],))
if store.rowcount():
store.log.info('Cleared txout %s', tx_hash)
| [
"def",
"clear_bad_addresses",
"(",
"store",
")",
":",
"bad_tx",
"=",
"[",
"'a288fec5559c3f73fd3d93db8e8460562ebfe2fcf04a5114e8d0f2920a6270dc'",
",",
"'2a0597e665ac3d1cabeede95cedf907934db7f639e477b3c77b242140d8cf728'",
",",
"'e411dbebd2f7d64dafeef9b14b5c59ec60c36779d43f850e5e347abee1e1a455... | set address=unknown for the bogus outputs in bitcoin 71036 . | train | false |
7,458 | def _get_course_credit_requirements(course_key):
credit_xblock_requirements = _get_credit_course_requirement_xblocks(course_key)
min_grade_requirement = _get_min_grade_requirement(course_key)
proctored_exams_requirements = _get_proctoring_requirements(course_key)
block_requirements = (credit_xblock_requirements + proctored_exams_requirements)
sorted_block_requirements = sorted(block_requirements, key=(lambda x: ((x['start_date'] is None), x['start_date'], x['display_name'])))
credit_requirements = (min_grade_requirement + sorted_block_requirements)
return credit_requirements
| [
"def",
"_get_course_credit_requirements",
"(",
"course_key",
")",
":",
"credit_xblock_requirements",
"=",
"_get_credit_course_requirement_xblocks",
"(",
"course_key",
")",
"min_grade_requirement",
"=",
"_get_min_grade_requirement",
"(",
"course_key",
")",
"proctored_exams_require... | returns the list of credit requirements for the given course . | train | false |
7,459 | @contextmanager
def augment_usage_errors(ctx, param=None):
try:
(yield)
except BadParameter as e:
if (e.ctx is None):
e.ctx = ctx
if ((param is not None) and (e.param is None)):
e.param = param
raise
except UsageError as e:
if (e.ctx is None):
e.ctx = ctx
raise
| [
"@",
"contextmanager",
"def",
"augment_usage_errors",
"(",
"ctx",
",",
"param",
"=",
"None",
")",
":",
"try",
":",
"(",
"yield",
")",
"except",
"BadParameter",
"as",
"e",
":",
"if",
"(",
"e",
".",
"ctx",
"is",
"None",
")",
":",
"e",
".",
"ctx",
"="... | context manager that attaches extra information to exceptions that fly . | train | true |
7,460 | def _BytesForNonRepeatedElement(value, field_number, field_type):
try:
fn = type_checkers.TYPE_TO_BYTE_SIZE_FN[field_type]
return fn(field_number, value)
except KeyError:
raise message_mod.EncodeError(('Unrecognized field type: %d' % field_type))
| [
"def",
"_BytesForNonRepeatedElement",
"(",
"value",
",",
"field_number",
",",
"field_type",
")",
":",
"try",
":",
"fn",
"=",
"type_checkers",
".",
"TYPE_TO_BYTE_SIZE_FN",
"[",
"field_type",
"]",
"return",
"fn",
"(",
"field_number",
",",
"value",
")",
"except",
... | returns the number of bytes needed to serialize a non-repeated element . | train | true |
7,461 | def test_resize_icon_list():
resize_size = [32, 82, 100]
final_size = [(32, 12), (82, 30), (100, 37)]
_uploader(resize_size, final_size)
| [
"def",
"test_resize_icon_list",
"(",
")",
":",
"resize_size",
"=",
"[",
"32",
",",
"82",
",",
"100",
"]",
"final_size",
"=",
"[",
"(",
"32",
",",
"12",
")",
",",
"(",
"82",
",",
"30",
")",
",",
"(",
"100",
",",
"37",
")",
"]",
"_uploader",
"(",... | resize multiple images at once . | train | false |
7,462 | def get_pasted_lines(sentinel, l_input=py3compat.input, quiet=False):
if (not quiet):
print ("Pasting code; enter '%s' alone on the line to stop or use Ctrl-D." % sentinel)
prompt = ':'
else:
prompt = ''
while True:
try:
l = l_input(prompt)
if (l == sentinel):
return
else:
(yield l)
except EOFError:
print '<EOF>'
return
| [
"def",
"get_pasted_lines",
"(",
"sentinel",
",",
"l_input",
"=",
"py3compat",
".",
"input",
",",
"quiet",
"=",
"False",
")",
":",
"if",
"(",
"not",
"quiet",
")",
":",
"print",
"(",
"\"Pasting code; enter '%s' alone on the line to stop or use Ctrl-D.\"",
"%",
"sent... | yield pasted lines until the user enters the given sentinel value . | train | false |
7,463 | def has_app(id):
return (_app_id(id) in apps()['apps'])
| [
"def",
"has_app",
"(",
"id",
")",
":",
"return",
"(",
"_app_id",
"(",
"id",
")",
"in",
"apps",
"(",
")",
"[",
"'apps'",
"]",
")"
] | return whether the given app id is currently configured . | train | false |
7,465 | def find_git_http_backend():
if hasattr(find_git_http_backend, 'result'):
return find_git_http_backend.result
try:
path = subprocess.check_output(['git', '--exec-path']).decode('utf-8')
if path:
GIT_PATHS.insert(0, path)
except OSError:
pass
for path in GIT_PATHS:
name = os.path.join(path, 'git-http-backend')
if os.path.exists(name):
find_git_http_backend.result = name
return name
| [
"def",
"find_git_http_backend",
"(",
")",
":",
"if",
"hasattr",
"(",
"find_git_http_backend",
",",
"'result'",
")",
":",
"return",
"find_git_http_backend",
".",
"result",
"try",
":",
"path",
"=",
"subprocess",
".",
"check_output",
"(",
"[",
"'git'",
",",
"'--e... | finds git http backend . | train | false |
7,466 | def _get_time_zone_dictionary(time_zone_name):
return {'time_zone': time_zone_name, 'description': get_display_time_zone(time_zone_name)}
| [
"def",
"_get_time_zone_dictionary",
"(",
"time_zone_name",
")",
":",
"return",
"{",
"'time_zone'",
":",
"time_zone_name",
",",
"'description'",
":",
"get_display_time_zone",
"(",
"time_zone_name",
")",
"}"
] | returns a dictionary of time zone information: * time_zone: name of pytz time zone * description: display version of time zone [e . | train | false |
7,468 | def find_test_driver():
test_driver = DefaultGalaxyTestDriver
for key in TEST_DRIVERS.keys():
if _check_arg(key):
test_driver = TEST_DRIVERS[key]
return test_driver
| [
"def",
"find_test_driver",
"(",
")",
":",
"test_driver",
"=",
"DefaultGalaxyTestDriver",
"for",
"key",
"in",
"TEST_DRIVERS",
".",
"keys",
"(",
")",
":",
"if",
"_check_arg",
"(",
"key",
")",
":",
"test_driver",
"=",
"TEST_DRIVERS",
"[",
"key",
"]",
"return",
... | look at command-line args and find the correct galaxy test driver . | train | false |
7,471 | def tear_down_repo(repo):
repo.close()
temp_dir = os.path.dirname(repo.path.rstrip(os.sep))
shutil.rmtree(temp_dir)
| [
"def",
"tear_down_repo",
"(",
"repo",
")",
":",
"repo",
".",
"close",
"(",
")",
"temp_dir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"repo",
".",
"path",
".",
"rstrip",
"(",
"os",
".",
"sep",
")",
")",
"shutil",
".",
"rmtree",
"(",
"temp_dir",
... | tear down a test repository . | train | false |
7,472 | def test_masking_regression_1795():
t = Table.read(os.path.join(DATA, 'tb.fits'))
assert np.all((t['c1'].mask == np.array([False, False])))
assert np.all((t['c2'].mask == np.array([False, False])))
assert np.all((t['c3'].mask == np.array([False, False])))
assert np.all((t['c4'].mask == np.array([False, False])))
assert np.all((t['c1'].data == np.array([1, 2])))
assert np.all((t['c2'].data == np.array(['abc', 'xy '])))
assert_allclose(t['c3'].data, np.array([3.70000007153, 6.6999997139]))
assert np.all((t['c4'].data == np.array([False, True])))
| [
"def",
"test_masking_regression_1795",
"(",
")",
":",
"t",
"=",
"Table",
".",
"read",
"(",
"os",
".",
"path",
".",
"join",
"(",
"DATA",
",",
"'tb.fits'",
")",
")",
"assert",
"np",
".",
"all",
"(",
"(",
"t",
"[",
"'c1'",
"]",
".",
"mask",
"==",
"n... | regression test for #1795 - this bug originally caused columns where tnull was not defined to have their first element masked . | train | false |
7,473 | def CleanFemPreg(df):
df.agepreg /= 100.0
df.birthwgt_lb[(df.birthwgt_lb > 20)] = np.nan
na_vals = [97, 98, 99]
df.birthwgt_lb.replace(na_vals, np.nan, inplace=True)
df.birthwgt_oz.replace(na_vals, np.nan, inplace=True)
df.hpagelb.replace(na_vals, np.nan, inplace=True)
df.babysex.replace([7, 9], np.nan, inplace=True)
df.nbrnaliv.replace([9], np.nan, inplace=True)
df['totalwgt_lb'] = (df.birthwgt_lb + (df.birthwgt_oz / 16.0))
df.cmintvw = np.nan
| [
"def",
"CleanFemPreg",
"(",
"df",
")",
":",
"df",
".",
"agepreg",
"/=",
"100.0",
"df",
".",
"birthwgt_lb",
"[",
"(",
"df",
".",
"birthwgt_lb",
">",
"20",
")",
"]",
"=",
"np",
".",
"nan",
"na_vals",
"=",
"[",
"97",
",",
"98",
",",
"99",
"]",
"df... | recodes variables from the pregnancy frame . | train | false |
7,474 | def solve_biquadratic(f, g, opt):
G = groebner([f, g])
if ((len(G) == 1) and G[0].is_ground):
return None
if (len(G) != 2):
raise SolveFailed
(p, q) = G
(x, y) = opt.gens
p = Poly(p, x, expand=False)
q = q.ltrim((-1))
p_roots = [rcollect(expr, y) for expr in roots(p).keys()]
q_roots = list(roots(q).keys())
solutions = []
for q_root in q_roots:
for p_root in p_roots:
solution = (p_root.subs(y, q_root), q_root)
solutions.append(solution)
return sorted(solutions, key=default_sort_key)
| [
"def",
"solve_biquadratic",
"(",
"f",
",",
"g",
",",
"opt",
")",
":",
"G",
"=",
"groebner",
"(",
"[",
"f",
",",
"g",
"]",
")",
"if",
"(",
"(",
"len",
"(",
"G",
")",
"==",
"1",
")",
"and",
"G",
"[",
"0",
"]",
".",
"is_ground",
")",
":",
"r... | solve a system of two bivariate quadratic polynomial equations . | train | false |
7,476 | def test_tilde(data):
session = PipSession()
with patch('pip.index.os.path.exists', return_value=True):
finder = PackageFinder(['~/python-pkgs'], [], session=session)
req = InstallRequirement.from_line('gmpy')
with pytest.raises(DistributionNotFound):
finder.find_requirement(req, False)
| [
"def",
"test_tilde",
"(",
"data",
")",
":",
"session",
"=",
"PipSession",
"(",
")",
"with",
"patch",
"(",
"'pip.index.os.path.exists'",
",",
"return_value",
"=",
"True",
")",
":",
"finder",
"=",
"PackageFinder",
"(",
"[",
"'~/python-pkgs'",
"]",
",",
"[",
... | finder can accept a path with ~ in it and will normalize it . | train | false |
7,477 | def check(actions, request, target=None):
policy_check = utils_settings.import_setting('POLICY_CHECK_FUNCTION')
if policy_check:
return policy_check(actions, request, target)
return True
| [
"def",
"check",
"(",
"actions",
",",
"request",
",",
"target",
"=",
"None",
")",
":",
"policy_check",
"=",
"utils_settings",
".",
"import_setting",
"(",
"'POLICY_CHECK_FUNCTION'",
")",
"if",
"policy_check",
":",
"return",
"policy_check",
"(",
"actions",
",",
"... | checks if a version is greater than the known version for <what> . | train | true |
7,478 | def sendline(command):
if (ping() is False):
init()
(out, err) = DETAILS[_worker_name()].sendline(command)
(_, out) = out.split('\n', 1)
(out, _, _) = out.rpartition('\n')
return out
| [
"def",
"sendline",
"(",
"command",
")",
":",
"if",
"(",
"ping",
"(",
")",
"is",
"False",
")",
":",
"init",
"(",
")",
"(",
"out",
",",
"err",
")",
"=",
"DETAILS",
"[",
"_worker_name",
"(",
")",
"]",
".",
"sendline",
"(",
"command",
")",
"(",
"_"... | run command through switchs cli . | train | false |
7,479 | def remove_container(container, force=False, v=False):
client = _get_client()
status = base_status.copy()
status['id'] = container
dcontainer = None
try:
dcontainer = _get_container_infos(container)['Id']
if is_running(dcontainer):
if (not force):
_invalid(status, id_=container, out=None, comment="Container {0} is running, won't remove it".format(container))
__salt__['mine.send']('dockerng.ps', verbose=True, all=True, host=True)
return status
else:
kill(dcontainer)
client.remove_container(dcontainer, v=v)
try:
_get_container_infos(dcontainer)
_invalid(status, comment='Container was not removed: {0}'.format(container))
except Exception:
status['status'] = True
status['comment'] = 'Container {0} was removed'.format(container)
except Exception:
_invalid(status, id_=container, out=traceback.format_exc())
__salt__['mine.send']('dockerng.ps', verbose=True, all=True, host=True)
return status
| [
"def",
"remove_container",
"(",
"container",
",",
"force",
"=",
"False",
",",
"v",
"=",
"False",
")",
":",
"client",
"=",
"_get_client",
"(",
")",
"status",
"=",
"base_status",
".",
"copy",
"(",
")",
"status",
"[",
"'id'",
"]",
"=",
"container",
"dcont... | remove a container from a docker installation container container id force remove a running container . | train | false |
7,480 | def compile_template_str(template, renderers, default, blacklist, whitelist):
fn_ = salt.utils.files.mkstemp()
with salt.utils.fopen(fn_, 'wb') as ofile:
ofile.write(SLS_ENCODER(template)[0])
return compile_template(fn_, renderers, default, blacklist, whitelist)
| [
"def",
"compile_template_str",
"(",
"template",
",",
"renderers",
",",
"default",
",",
"blacklist",
",",
"whitelist",
")",
":",
"fn_",
"=",
"salt",
".",
"utils",
".",
"files",
".",
"mkstemp",
"(",
")",
"with",
"salt",
".",
"utils",
".",
"fopen",
"(",
"... | take template as a string and return the high data structure derived from the template . | train | true |
7,482 | def getGeometryOutputByArguments(arguments, elementNode):
evaluate.setAttributesByArguments(['sides', 'radius'], arguments, elementNode)
return getGeometryOutput(None, elementNode)
| [
"def",
"getGeometryOutputByArguments",
"(",
"arguments",
",",
"elementNode",
")",
":",
"evaluate",
".",
"setAttributesByArguments",
"(",
"[",
"'sides'",
",",
"'radius'",
"]",
",",
"arguments",
",",
"elementNode",
")",
"return",
"getGeometryOutput",
"(",
"None",
",... | get vector3 vertexes from attribute dictionary by arguments . | train | false |
7,483 | def _get_form_descriptions(request):
return {'login': _local_server_get('/user_api/v1/account/login_session/', request.session), 'registration': _local_server_get('/user_api/v1/account/registration/', request.session), 'password_reset': _local_server_get('/user_api/v1/account/password_reset/', request.session)}
| [
"def",
"_get_form_descriptions",
"(",
"request",
")",
":",
"return",
"{",
"'login'",
":",
"_local_server_get",
"(",
"'/user_api/v1/account/login_session/'",
",",
"request",
".",
"session",
")",
",",
"'registration'",
":",
"_local_server_get",
"(",
"'/user_api/v1/account... | retrieve form descriptions from the user api . | train | false |
7,484 | def test_low_gamma():
win = visual.Window([600, 600], gamma=0.5, autoLog=False)
for n in range(5):
win.flip()
assert (win.useNativeGamma == False)
win.close()
| [
"def",
"test_low_gamma",
"(",
")",
":",
"win",
"=",
"visual",
".",
"Window",
"(",
"[",
"600",
",",
"600",
"]",
",",
"gamma",
"=",
"0.5",
",",
"autoLog",
"=",
"False",
")",
"for",
"n",
"in",
"range",
"(",
"5",
")",
":",
"win",
".",
"flip",
"(",
... | setting gamma low . | train | false |
7,485 | def safe_string(value):
if isinstance(value, NUMERIC_TYPES):
value = ('%.16g' % value)
elif (value is None):
value = 'none'
elif (not isinstance(value, basestring)):
value = str(value)
return value
| [
"def",
"safe_string",
"(",
"value",
")",
":",
"if",
"isinstance",
"(",
"value",
",",
"NUMERIC_TYPES",
")",
":",
"value",
"=",
"(",
"'%.16g'",
"%",
"value",
")",
"elif",
"(",
"value",
"is",
"None",
")",
":",
"value",
"=",
"'none'",
"elif",
"(",
"not",... | safely and consistently format numeric values . | train | false |
7,486 | def triangulate(vertices):
n = len(vertices)
vertices = np.asarray(vertices)
zmean = vertices[:, 2].mean()
vertices_2d = vertices[:, :2]
segments = np.repeat(np.arange((n + 1)), 2)[1:(-1)]
segments[(-2):] = ((n - 1), 0)
if _TRIANGLE_AVAILABLE:
(vertices_2d, triangles) = _triangulate_cpp(vertices_2d, segments)
else:
(vertices_2d, triangles) = _triangulate_python(vertices_2d, segments)
vertices = np.empty((len(vertices_2d), 3))
vertices[:, :2] = vertices_2d
vertices[:, 2] = zmean
return (vertices, triangles)
| [
"def",
"triangulate",
"(",
"vertices",
")",
":",
"n",
"=",
"len",
"(",
"vertices",
")",
"vertices",
"=",
"np",
".",
"asarray",
"(",
"vertices",
")",
"zmean",
"=",
"vertices",
"[",
":",
",",
"2",
"]",
".",
"mean",
"(",
")",
"vertices_2d",
"=",
"vert... | two-view triangulation of points in x1 . | train | true |
7,489 | def _UTC():
return utc
| [
"def",
"_UTC",
"(",
")",
":",
"return",
"utc"
] | factory function for utc unpickling . | train | false |
7,490 | def assert_clock_idle(case, clock):
case.assertEqual(clock.getDelayedCalls(), [])
| [
"def",
"assert_clock_idle",
"(",
"case",
",",
"clock",
")",
":",
"case",
".",
"assertEqual",
"(",
"clock",
".",
"getDelayedCalls",
"(",
")",
",",
"[",
"]",
")"
] | assert that the given clock doesnt have any pending delayed calls . | train | false |
7,493 | def pathsplit(path):
result = []
(head, tail) = _os.path.split(path)
if ((not head) or (head == path)):
pass
else:
result = pathsplit(head)
if tail:
result += [tail]
return result
| [
"def",
"pathsplit",
"(",
"path",
")",
":",
"result",
"=",
"[",
"]",
"(",
"head",
",",
"tail",
")",
"=",
"_os",
".",
"path",
".",
"split",
"(",
"path",
")",
"if",
"(",
"(",
"not",
"head",
")",
"or",
"(",
"head",
"==",
"path",
")",
")",
":",
... | split a path into a list of elements of the file system hierarchy . | train | false |
7,495 | def S_crosssection(x, group):
x_group_sums = group_sums(x, group).T
return S_white_simple(x_group_sums)
| [
"def",
"S_crosssection",
"(",
"x",
",",
"group",
")",
":",
"x_group_sums",
"=",
"group_sums",
"(",
"x",
",",
"group",
")",
".",
"T",
"return",
"S_white_simple",
"(",
"x_group_sums",
")"
] | inner covariance matrix for white on group sums sandwich i guess for a single categorical group only . | train | false |
7,496 | def read_cert_from_file(cert_file, cert_type):
if (not cert_file):
return ''
if (cert_type == 'pem'):
line = open(cert_file).read().replace('\r\n', '\n').split('\n')
if (line[0] == '-----BEGIN CERTIFICATE-----'):
line = line[1:]
elif (line[0] == '-----BEGIN PUBLIC KEY-----'):
line = line[1:]
else:
raise CertificateError('Strange beginning of PEM file')
while (line[(-1)] == ''):
line = line[:(-1)]
if (line[(-1)] == '-----END CERTIFICATE-----'):
line = line[:(-1)]
elif (line[(-1)] == '-----END PUBLIC KEY-----'):
line = line[:(-1)]
else:
raise CertificateError('Strange end of PEM file')
return ''.join(line)
if (cert_type in ['der', 'cer', 'crt']):
data = read_file(cert_file)
return base64.b64encode(str(data))
| [
"def",
"read_cert_from_file",
"(",
"cert_file",
",",
"cert_type",
")",
":",
"if",
"(",
"not",
"cert_file",
")",
":",
"return",
"''",
"if",
"(",
"cert_type",
"==",
"'pem'",
")",
":",
"line",
"=",
"open",
"(",
"cert_file",
")",
".",
"read",
"(",
")",
"... | reads a certificate from a file . | train | false |
7,499 | def purestr(x):
if (not isinstance(x, Basic)):
return str(x)
if (type(x) in slotClasses):
args = [getattr(x, slot) for slot in x.__slots__]
elif (type(x) in sort_classes):
args = sorted(x.args, key=default_sort_key)
else:
args = x.args
return ('%s(%s)' % (type(x).__name__, ', '.join(map(purestr, args))))
| [
"def",
"purestr",
"(",
"x",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"x",
",",
"Basic",
")",
")",
":",
"return",
"str",
"(",
"x",
")",
"if",
"(",
"type",
"(",
"x",
")",
"in",
"slotClasses",
")",
":",
"args",
"=",
"[",
"getattr",
"(",
"x... | a string that follows obj = type exactly . | train | false |
7,500 | @verbose
def spatial_src_connectivity(src, dist=None, verbose=None):
return spatio_temporal_src_connectivity(src, 1, dist)
| [
"@",
"verbose",
"def",
"spatial_src_connectivity",
"(",
"src",
",",
"dist",
"=",
"None",
",",
"verbose",
"=",
"None",
")",
":",
"return",
"spatio_temporal_src_connectivity",
"(",
"src",
",",
"1",
",",
"dist",
")"
] | compute connectivity for a source space activation . | train | false |
7,501 | def _have_bug17666():
if (os.name == 'java'):
return False
import gzip
bgzf_eof = ('\x1f\x8b\x08\x04\x00\x00\x00\x00\x00\xff\x06\x00BC' + '\x02\x00\x1b\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00')
if (sys.version_info[0] >= 3):
import codecs
bgzf_eof = codecs.latin_1_encode(bgzf_eof)[0]
h = gzip.GzipFile(fileobj=BytesIO(bgzf_eof))
try:
data = h.read()
h.close()
assert (not data), ('Should be zero length, not %i' % len(data))
return False
except TypeError as err:
h.close()
return True
| [
"def",
"_have_bug17666",
"(",
")",
":",
"if",
"(",
"os",
".",
"name",
"==",
"'java'",
")",
":",
"return",
"False",
"import",
"gzip",
"bgzf_eof",
"=",
"(",
"'\\x1f\\x8b\\x08\\x04\\x00\\x00\\x00\\x00\\x00\\xff\\x06\\x00BC'",
"+",
"'\\x02\\x00\\x1b\\x00\\x03\\x00\\x00\\x00... | debug function to check if pythons gzip is broken . | train | false |
7,502 | def new_document(source_path, settings=None):
from docutils import frontend
if (settings is None):
settings = frontend.OptionParser().get_default_values()
source_path = decode_path(source_path)
reporter = new_reporter(source_path, settings)
document = nodes.document(settings, reporter, source=source_path)
document.note_source(source_path, (-1))
return document
| [
"def",
"new_document",
"(",
"source_path",
",",
"settings",
"=",
"None",
")",
":",
"from",
"docutils",
"import",
"frontend",
"if",
"(",
"settings",
"is",
"None",
")",
":",
"settings",
"=",
"frontend",
".",
"OptionParser",
"(",
")",
".",
"get_default_values",... | return a new empty document object . | train | false |
7,503 | def is_raising(body):
for node in body:
if isinstance(node, astroid.Raise):
return True
return False
| [
"def",
"is_raising",
"(",
"body",
")",
":",
"for",
"node",
"in",
"body",
":",
"if",
"isinstance",
"(",
"node",
",",
"astroid",
".",
"Raise",
")",
":",
"return",
"True",
"return",
"False"
] | return true if the given statement node raise an exception . | train | false |
7,504 | def get_versions_for_exploration_stats(exploration_id):
return stats_models.ExplorationAnnotationsModel.get_versions(exploration_id)
| [
"def",
"get_versions_for_exploration_stats",
"(",
"exploration_id",
")",
":",
"return",
"stats_models",
".",
"ExplorationAnnotationsModel",
".",
"get_versions",
"(",
"exploration_id",
")"
] | returns list of versions for this exploration . | train | false |
7,505 | def version_info():
Version = namedtuple('Version', 'major, minor, micro')
from jedi import __version__
tupl = re.findall('[a-z]+|\\d+', __version__)
return Version(*[(x if (i == 3) else int(x)) for (i, x) in enumerate(tupl)])
| [
"def",
"version_info",
"(",
")",
":",
"Version",
"=",
"namedtuple",
"(",
"'Version'",
",",
"'major, minor, micro'",
")",
"from",
"jedi",
"import",
"__version__",
"tupl",
"=",
"re",
".",
"findall",
"(",
"'[a-z]+|\\\\d+'",
",",
"__version__",
")",
"return",
"Ver... | returns a namedtuple of jedis version . | train | false |
7,507 | def _failureOldStyle(fail):
import linecache
tb = []
for f in fail.frames:
tb.append((f[1], f[2], f[0], linecache.getline(f[1], f[2])))
return {'traceback': tb, 'exception': traceback.format_exception_only(fail.type, fail.value)}
| [
"def",
"_failureOldStyle",
"(",
"fail",
")",
":",
"import",
"linecache",
"tb",
"=",
"[",
"]",
"for",
"f",
"in",
"fail",
".",
"frames",
":",
"tb",
".",
"append",
"(",
"(",
"f",
"[",
"1",
"]",
",",
"f",
"[",
"2",
"]",
",",
"f",
"[",
"0",
"]",
... | pre-failure manhole representation of exceptions . | train | false |
7,508 | @treeio_login_required
def widget_index_assigned(request, response_format='html'):
context = _get_default_context(request)
agent = context['agent']
if agent:
tickets = Object.filter_by_request(request, Ticket.objects.filter(assigned=agent, status__hidden=False))
else:
return user_denied(request, 'You are not a Service Support Agent.')
context.update({'tickets': tickets})
return render_to_response('services/widgets/index_assigned', context, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"treeio_login_required",
"def",
"widget_index_assigned",
"(",
"request",
",",
"response_format",
"=",
"'html'",
")",
":",
"context",
"=",
"_get_default_context",
"(",
"request",
")",
"agent",
"=",
"context",
"[",
"'agent'",
"]",
"if",
"agent",
":",
"tickets... | tickets assigned to current user . | train | false |
7,509 | @nottest
def make_test_handler(testcase, *args, **kwargs):
handler = TestHandler(*args, **kwargs)
testcase.addCleanup(handler.close)
return handler
| [
"@",
"nottest",
"def",
"make_test_handler",
"(",
"testcase",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"handler",
"=",
"TestHandler",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
"testcase",
".",
"addCleanup",
"(",
"handler",
".",
"close",
")",
"... | returns a testhandler which will be used by the given testcase . | train | false |
7,510 | def _get_info(info, name):
try:
idx = info[name]
except:
idx = info[name] = dict()
return idx
| [
"def",
"_get_info",
"(",
"info",
",",
"name",
")",
":",
"try",
":",
"idx",
"=",
"info",
"[",
"name",
"]",
"except",
":",
"idx",
"=",
"info",
"[",
"name",
"]",
"=",
"dict",
"(",
")",
"return",
"idx"
] | get/create the info for this name . | train | true |
7,512 | def get_new_obj(obj, klass, attributes):
kwargs = {}
for (key, value) in list(obj.__dict__.items()):
if isinstance(value, dict):
kwargs[key] = value.copy()
elif isinstance(value, (tuple, list)):
kwargs[key] = value[:]
else:
kwargs[key] = value
for (key, value) in list(attributes.items()):
if (value is None):
continue
if isinstance(value, dict):
kwargs_value = kwargs.get(key, {})
for (key1, value2) in list(value.items()):
if (value2 is None):
continue
kwargs_value[key1] = value2
kwargs[key] = kwargs_value
else:
kwargs[key] = value
return klass(**kwargs)
| [
"def",
"get_new_obj",
"(",
"obj",
",",
"klass",
",",
"attributes",
")",
":",
"kwargs",
"=",
"{",
"}",
"for",
"(",
"key",
",",
"value",
")",
"in",
"list",
"(",
"obj",
".",
"__dict__",
".",
"items",
"(",
")",
")",
":",
"if",
"isinstance",
"(",
"val... | pass attributes from the existing object obj and attributes dictionary to a klass constructor . | train | false |
7,514 | def extractOne(query, choices, processor=default_processor, scorer=default_scorer, score_cutoff=0):
best_list = extractWithoutOrder(query, choices, processor, scorer, score_cutoff)
try:
return max(best_list, key=(lambda i: i[1]))
except ValueError:
return None
| [
"def",
"extractOne",
"(",
"query",
",",
"choices",
",",
"processor",
"=",
"default_processor",
",",
"scorer",
"=",
"default_scorer",
",",
"score_cutoff",
"=",
"0",
")",
":",
"best_list",
"=",
"extractWithoutOrder",
"(",
"query",
",",
"choices",
",",
"processor... | find the single best match above a score in a list of choices . | train | true |
7,515 | def log1p(x):
return Log1p()(x)
| [
"def",
"log1p",
"(",
"x",
")",
":",
"return",
"Log1p",
"(",
")",
"(",
"x",
")"
] | elementwise natural logarithm plus one function . | train | false |
7,516 | def get_region_from_metadata():
global __Location__
if (__Location__ == 'do-not-get-from-metadata'):
LOG.debug('Previously failed to get AWS region from metadata. Not trying again.')
return None
if (__Location__ != ''):
return __Location__
try:
result = requests.get('http://169.254.169.254/latest/dynamic/instance-identity/document', proxies={'http': ''}, timeout=AWS_METADATA_TIMEOUT)
except requests.exceptions.RequestException:
LOG.warning('Failed to get AWS region from instance metadata.', exc_info=True)
__Location__ = 'do-not-get-from-metadata'
return None
try:
region = result.json()['region']
__Location__ = region
return __Location__
except (ValueError, KeyError):
LOG.warning('Failed to decode JSON from instance metadata.')
return None
return None
| [
"def",
"get_region_from_metadata",
"(",
")",
":",
"global",
"__Location__",
"if",
"(",
"__Location__",
"==",
"'do-not-get-from-metadata'",
")",
":",
"LOG",
".",
"debug",
"(",
"'Previously failed to get AWS region from metadata. Not trying again.'",
")",
"return",
"None",
... | try to get region from instance identity document and cache it . | train | true |
7,517 | def _check_module(evaluator, module):
def get_sys_path_powers(names):
for name in names:
power = name.parent.parent
if tree.is_node(power, 'power', 'atom_expr'):
c = power.children
if (isinstance(c[0], tree.Name) and (c[0].value == 'sys') and tree.is_node(c[1], 'trailer')):
n = c[1].children[1]
if (isinstance(n, tree.Name) and (n.value == 'path')):
(yield (name, power))
sys_path = list(evaluator.sys_path)
try:
possible_names = module.used_names['path']
except KeyError:
pass
else:
for (name, power) in get_sys_path_powers(possible_names):
stmt = name.get_definition()
if (len(power.children) >= 4):
sys_path.extend(_paths_from_list_modifications(module.path, *power.children[2:4]))
elif (name.get_definition().type == 'expr_stmt'):
sys_path.extend(_paths_from_assignment(evaluator, stmt))
return sys_path
| [
"def",
"_check_module",
"(",
"evaluator",
",",
"module",
")",
":",
"def",
"get_sys_path_powers",
"(",
"names",
")",
":",
"for",
"name",
"in",
"names",
":",
"power",
"=",
"name",
".",
"parent",
".",
"parent",
"if",
"tree",
".",
"is_node",
"(",
"power",
... | detect sys . | train | false |
7,518 | def install_update(name):
salt.utils.warn_until('Fluorine', "This function is replaced by 'install' as of Salt Nitrogen. Thiswarning will be removed in Salt Fluorine.")
return install(name)
| [
"def",
"install_update",
"(",
"name",
")",
":",
"salt",
".",
"utils",
".",
"warn_until",
"(",
"'Fluorine'",
",",
"\"This function is replaced by 'install' as of Salt Nitrogen. Thiswarning will be removed in Salt Fluorine.\"",
")",
"return",
"install",
"(",
"name",
")"
] | if a newer release is available . | train | false |
7,519 | @utils.arg('host', metavar='<host>', help='Name of host.')
def do_host_servers_migrate(cs, args):
hypervisors = cs.hypervisors.search(args.host, servers=True)
response = []
for hyper in hypervisors:
if hasattr(hyper, 'servers'):
for server in hyper.servers:
response.append(_server_migrate(cs, server))
utils.print_list(response, ['Server UUID', 'Migration Accepted', 'Error Message'])
| [
"@",
"utils",
".",
"arg",
"(",
"'host'",
",",
"metavar",
"=",
"'<host>'",
",",
"help",
"=",
"'Name of host.'",
")",
"def",
"do_host_servers_migrate",
"(",
"cs",
",",
"args",
")",
":",
"hypervisors",
"=",
"cs",
".",
"hypervisors",
".",
"search",
"(",
"arg... | cold migrate all instances off the specified host to other available hosts . | train | false |
7,521 | def pick_context_manager_writer(f):
@functools.wraps(f)
def wrapped(context, *args, **kwargs):
ctxt_mgr = get_context_manager(context)
with ctxt_mgr.writer.using(context):
return f(context, *args, **kwargs)
return wrapped
| [
"def",
"pick_context_manager_writer",
"(",
"f",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"f",
")",
"def",
"wrapped",
"(",
"context",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"ctxt_mgr",
"=",
"get_context_manager",
"(",
"context",
")",
"with... | decorator to use a writer db context manager . | train | false |
7,524 | def say_text(text, priority='important'):
mpstate.console.writeln(text)
| [
"def",
"say_text",
"(",
"text",
",",
"priority",
"=",
"'important'",
")",
":",
"mpstate",
".",
"console",
".",
"writeln",
"(",
"text",
")"
] | text output - default function for say() . | train | false |
7,525 | def _MapFileToMsBuildSourceType(source, rule_dependencies, extension_to_rule_name):
(_, ext) = os.path.splitext(source)
if (ext in extension_to_rule_name):
group = 'rule'
element = extension_to_rule_name[ext]
elif (ext in ['.cc', '.cpp', '.c', '.cxx']):
group = 'compile'
element = 'ClCompile'
elif (ext in ['.h', '.hxx']):
group = 'include'
element = 'ClInclude'
elif (ext == '.rc'):
group = 'resource'
element = 'ResourceCompile'
elif (ext == '.asm'):
group = 'masm'
element = 'MASM'
elif (ext == '.idl'):
group = 'midl'
element = 'Midl'
elif (source in rule_dependencies):
group = 'rule_dependency'
element = 'CustomBuild'
else:
group = 'none'
element = 'None'
return (group, element)
| [
"def",
"_MapFileToMsBuildSourceType",
"(",
"source",
",",
"rule_dependencies",
",",
"extension_to_rule_name",
")",
":",
"(",
"_",
",",
"ext",
")",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"source",
")",
"if",
"(",
"ext",
"in",
"extension_to_rule_name",
... | returns the group and element type of the source file . | train | false |
7,527 | def _get_mro(cls):
if (not isinstance(cls, type)):
class cls(cls, object, ):
pass
return cls.__mro__[1:]
return cls.__mro__
| [
"def",
"_get_mro",
"(",
"cls",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"cls",
",",
"type",
")",
")",
":",
"class",
"cls",
"(",
"cls",
",",
"object",
",",
")",
":",
"pass",
"return",
"cls",
".",
"__mro__",
"[",
"1",
":",
"]",
"return",
"c... | get a reasonable method resolution order of a class and its superclasses for both old-style and new-style classes . | train | true |
7,528 | def silverman_transform(bw, M, RANGE):
J = np.arange(((M / 2) + 1))
FAC1 = (2 * (((np.pi * bw) / RANGE) ** 2))
JFAC = ((J ** 2) * FAC1)
BC = (1 - ((1.0 / 3) * ((((J * 1.0) / M) * np.pi) ** 2)))
FAC = (np.exp((- JFAC)) / BC)
kern_est = np.r_[(FAC, FAC[1:(-1)])]
return kern_est
| [
"def",
"silverman_transform",
"(",
"bw",
",",
"M",
",",
"RANGE",
")",
":",
"J",
"=",
"np",
".",
"arange",
"(",
"(",
"(",
"M",
"/",
"2",
")",
"+",
"1",
")",
")",
"FAC1",
"=",
"(",
"2",
"*",
"(",
"(",
"(",
"np",
".",
"pi",
"*",
"bw",
")",
... | fft of gaussian kernel following to silverman as 176 . | train | false |
7,531 | def get_product_summary_serializer_class():
return _product_summary_serializer_class
| [
"def",
"get_product_summary_serializer_class",
"(",
")",
":",
"return",
"_product_summary_serializer_class"
] | returns the the common productserializer . | train | false |
7,532 | def run_tasks(guest, instance, active_migrations, on_migration_failure, migration, is_post_copy_enabled):
tasks = active_migrations.get(instance.uuid, deque())
while tasks:
task = tasks.popleft()
if (task == 'force-complete'):
if (migration.status == 'running (post-copy)'):
LOG.warning(_LW('Live-migration %s already switched to post-copy mode.'), instance=instance)
elif is_post_copy_enabled:
trigger_postcopy_switch(guest, instance, migration)
else:
try:
guest.pause()
on_migration_failure.append('unpause')
except Exception as e:
LOG.warning(_LW('Failed to pause instance during live-migration %s'), e, instance=instance)
else:
LOG.warning(_LW("Unknown migration task '%(task)s'"), {'task': task}, instance=instance)
| [
"def",
"run_tasks",
"(",
"guest",
",",
"instance",
",",
"active_migrations",
",",
"on_migration_failure",
",",
"migration",
",",
"is_post_copy_enabled",
")",
":",
"tasks",
"=",
"active_migrations",
".",
"get",
"(",
"instance",
".",
"uuid",
",",
"deque",
"(",
"... | run any pending migration tasks . | train | false |
7,533 | def assert_sp_frame_equal(left, right, check_dtype=True, exact_indices=True, check_frame_type=True, obj='SparseDataFrame'):
assertIsInstance(left, pd.SparseDataFrame, '[SparseDataFrame]')
assertIsInstance(right, pd.SparseDataFrame, '[SparseDataFrame]')
if check_frame_type:
assert_class_equal(left, right, obj=obj)
assert_index_equal(left.index, right.index, obj='{0}.index'.format(obj))
assert_index_equal(left.columns, right.columns, obj='{0}.columns'.format(obj))
for (col, series) in compat.iteritems(left):
assert (col in right)
if exact_indices:
assert_sp_series_equal(series, right[col], check_dtype=check_dtype)
else:
assert_series_equal(series.to_dense(), right[col].to_dense(), check_dtype=check_dtype)
assert_attr_equal('default_fill_value', left, right, obj=obj)
for col in right:
assert (col in left)
| [
"def",
"assert_sp_frame_equal",
"(",
"left",
",",
"right",
",",
"check_dtype",
"=",
"True",
",",
"exact_indices",
"=",
"True",
",",
"check_frame_type",
"=",
"True",
",",
"obj",
"=",
"'SparseDataFrame'",
")",
":",
"assertIsInstance",
"(",
"left",
",",
"pd",
"... | check that the left and right sparsedataframe are equal . | train | false |
7,534 | def is_mul(var):
if (var.owner and (var.owner.op == tensor.mul)):
return var.owner.inputs
else:
return None
| [
"def",
"is_mul",
"(",
"var",
")",
":",
"if",
"(",
"var",
".",
"owner",
"and",
"(",
"var",
".",
"owner",
".",
"op",
"==",
"tensor",
".",
"mul",
")",
")",
":",
"return",
"var",
".",
"owner",
".",
"inputs",
"else",
":",
"return",
"None"
] | match a variable with x * y * z * . | train | false |
7,535 | def get_attributes(path):
err = ''
if (not os.path.exists(path)):
err += 'File not found\n'
if err:
return err
attributes = {}
intAttributes = win32file.GetFileAttributes(path)
attributes['archive'] = ((intAttributes & 32) == 32)
attributes['reparsePoint'] = ((intAttributes & 1024) == 1024)
attributes['compressed'] = ((intAttributes & 2048) == 2048)
attributes['directory'] = ((intAttributes & 16) == 16)
attributes['encrypted'] = ((intAttributes & 16384) == 16384)
attributes['hidden'] = ((intAttributes & 2) == 2)
attributes['normal'] = ((intAttributes & 128) == 128)
attributes['notIndexed'] = ((intAttributes & 8192) == 8192)
attributes['offline'] = ((intAttributes & 4096) == 4096)
attributes['readonly'] = ((intAttributes & 1) == 1)
attributes['system'] = ((intAttributes & 4) == 4)
attributes['temporary'] = ((intAttributes & 256) == 256)
attributes['mountedVolume'] = False
if ((attributes['reparsePoint'] is True) and (attributes['directory'] is True)):
fileIterator = win32file.FindFilesIterator(path)
findDataTuple = next(fileIterator)
if (findDataTuple[6] == 2684354563):
attributes['mountedVolume'] = True
attributes['symbolicLink'] = False
if (attributes['reparsePoint'] is True):
fileIterator = win32file.FindFilesIterator(path)
findDataTuple = next(fileIterator)
if (findDataTuple[6] == 2684354572):
attributes['symbolicLink'] = True
return attributes
| [
"def",
"get_attributes",
"(",
"path",
")",
":",
"err",
"=",
"''",
"if",
"(",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"path",
")",
")",
":",
"err",
"+=",
"'File not found\\n'",
"if",
"err",
":",
"return",
"err",
"attributes",
"=",
"{",
"}",
"i... | check to see if attributes are set on an elb . | train | true |
7,536 | def getAllPaths(paths, xmlObject):
for archivableObject in xmlObject.archivableObjects:
paths += archivableObject.getPaths()
return paths
| [
"def",
"getAllPaths",
"(",
"paths",
",",
"xmlObject",
")",
":",
"for",
"archivableObject",
"in",
"xmlObject",
".",
"archivableObjects",
":",
"paths",
"+=",
"archivableObject",
".",
"getPaths",
"(",
")",
"return",
"paths"
] | get all paths . | train | false |
7,537 | def _maketrans(complement_mapping):
before = ''.join(complement_mapping.keys())
after = ''.join(complement_mapping.values())
before += before.lower()
after += after.lower()
if (sys.version_info[0] == 3):
return str.maketrans(before, after)
else:
return string.maketrans(before, after)
| [
"def",
"_maketrans",
"(",
"complement_mapping",
")",
":",
"before",
"=",
"''",
".",
"join",
"(",
"complement_mapping",
".",
"keys",
"(",
")",
")",
"after",
"=",
"''",
".",
"join",
"(",
"complement_mapping",
".",
"values",
"(",
")",
")",
"before",
"+=",
... | makes a python string translation table . | train | false |
7,540 | def reconstruct_matrix_from_id(B, idx, proj):
if _is_real(B):
return backend.idd_reconid(B, (idx + 1), proj)
else:
return backend.idz_reconid(B, (idx + 1), proj)
| [
"def",
"reconstruct_matrix_from_id",
"(",
"B",
",",
"idx",
",",
"proj",
")",
":",
"if",
"_is_real",
"(",
"B",
")",
":",
"return",
"backend",
".",
"idd_reconid",
"(",
"B",
",",
"(",
"idx",
"+",
"1",
")",
",",
"proj",
")",
"else",
":",
"return",
"bac... | reconstruct matrix from its id . | train | false |
7,541 | @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('student', 'url', 'due_datetime')
def change_due_date(request, course_id):
course = get_course_by_id(SlashSeparatedCourseKey.from_deprecated_string(course_id))
student = require_student_from_identifier(request.POST.get('student'))
unit = find_unit(course, request.POST.get('url'))
due_date = parse_datetime(request.POST.get('due_datetime'))
set_due_date_extension(course, unit, student, due_date)
return JsonResponse(_('Successfully changed due date for student {0} for {1} to {2}').format(student.profile.name, _display_unit(unit), due_date.strftime('%Y-%m-%d %H:%M')))
| [
"@",
"handle_dashboard_error",
"@",
"require_POST",
"@",
"ensure_csrf_cookie",
"@",
"cache_control",
"(",
"no_cache",
"=",
"True",
",",
"no_store",
"=",
"True",
",",
"must_revalidate",
"=",
"True",
")",
"@",
"require_level",
"(",
"'staff'",
")",
"@",
"require_po... | grants a due date extension to a student for a particular unit . | train | false |
7,542 | def hb_write(file, m, hb_info=None):
if (hb_info is None):
hb_info = HBInfo.from_data(m)
def _set_matrix(fid):
hb = HBFile(fid, hb_info)
return hb.write_matrix(m)
if isinstance(file, string_types):
fid = open(file, 'w')
try:
return _set_matrix(fid)
finally:
fid.close()
else:
return _set_matrix(file)
| [
"def",
"hb_write",
"(",
"file",
",",
"m",
",",
"hb_info",
"=",
"None",
")",
":",
"if",
"(",
"hb_info",
"is",
"None",
")",
":",
"hb_info",
"=",
"HBInfo",
".",
"from_data",
"(",
"m",
")",
"def",
"_set_matrix",
"(",
"fid",
")",
":",
"hb",
"=",
"HBFi... | write hb-format file . | train | false |
7,543 | def simplecatcher(application):
def simplecatcher_app(environ, start_response):
try:
return application(environ, start_response)
except:
out = StringIO()
traceback.print_exc(file=out)
start_response('500 Server Error', [('content-type', 'text/html')], sys.exc_info())
res = out.getvalue()
return [('<h3>Error</h3><pre>%s</pre>' % html_quote(res))]
return simplecatcher_app
| [
"def",
"simplecatcher",
"(",
"application",
")",
":",
"def",
"simplecatcher_app",
"(",
"environ",
",",
"start_response",
")",
":",
"try",
":",
"return",
"application",
"(",
"environ",
",",
"start_response",
")",
"except",
":",
"out",
"=",
"StringIO",
"(",
")... | a simple middleware that catches errors and turns them into simple tracebacks . | train | false |
7,544 | def lookupAddress6(name, timeout=None):
return getResolver().lookupAddress6(name, timeout)
| [
"def",
"lookupAddress6",
"(",
"name",
",",
"timeout",
"=",
"None",
")",
":",
"return",
"getResolver",
"(",
")",
".",
"lookupAddress6",
"(",
"name",
",",
"timeout",
")"
] | perform an a6 record lookup . | train | false |
7,545 | def get_saml_client():
if settings.SAML_CALLBACK_SERVER_NAME:
acs_url = (settings.SAML_CALLBACK_SERVER_NAME + url_for('saml_auth.idp_initiated'))
else:
acs_url = url_for('saml_auth.idp_initiated', _external=True)
if (settings.SAML_METADATA_URL != ''):
rv = requests.get(settings.SAML_METADATA_URL)
import tempfile
tmp = tempfile.NamedTemporaryFile()
f = open(tmp.name, 'w')
f.write(rv.text)
f.close()
metadata_path = tmp.name
else:
metadata_path = settings.SAML_LOCAL_METADATA_PATH
saml_settings = {'metadata': {'local': [metadata_path]}, 'service': {'sp': {'endpoints': {'assertion_consumer_service': [(acs_url, BINDING_HTTP_REDIRECT), (acs_url, BINDING_HTTP_POST)]}, 'allow_unsolicited': True, 'authn_requests_signed': False, 'logout_requests_signed': True, 'want_assertions_signed': True, 'want_response_signed': False}}}
if (settings.SAML_ENTITY_ID != ''):
saml_settings['entityid'] = settings.SAML_ENTITY_ID
spConfig = Saml2Config()
spConfig.load(saml_settings)
spConfig.allow_unknown_attributes = True
saml_client = Saml2Client(config=spConfig)
if (settings.SAML_METADATA_URL != ''):
tmp.close()
return saml_client
| [
"def",
"get_saml_client",
"(",
")",
":",
"if",
"settings",
".",
"SAML_CALLBACK_SERVER_NAME",
":",
"acs_url",
"=",
"(",
"settings",
".",
"SAML_CALLBACK_SERVER_NAME",
"+",
"url_for",
"(",
"'saml_auth.idp_initiated'",
")",
")",
"else",
":",
"acs_url",
"=",
"url_for",... | return saml configuration . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.