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 |
|---|---|---|---|---|---|
6,491 | def decode_list(data):
rv = []
for item in data:
if (isinstance(item, six.text_type) and six.PY2):
item = item.encode('utf-8')
elif isinstance(item, list):
item = decode_list(item)
elif isinstance(item, dict):
item = decode_dict(item)
rv.append(item)
return rv
| [
"def",
"decode_list",
"(",
"data",
")",
":",
"rv",
"=",
"[",
"]",
"for",
"item",
"in",
"data",
":",
"if",
"(",
"isinstance",
"(",
"item",
",",
"six",
".",
"text_type",
")",
"and",
"six",
".",
"PY2",
")",
":",
"item",
"=",
"item",
".",
"encode",
... | json decodes as unicode . | train | false |
6,492 | def check_force_season_folders(pattern=None, multi=None, anime_type=None):
if (pattern is None):
pattern = sickbeard.NAMING_PATTERN
if (anime_type is None):
anime_type = sickbeard.NAMING_ANIME
valid = (not validate_name(pattern, None, anime_type, file_only=True))
if (multi is not None):
valid = (valid or (not validate_name(pattern, multi, anime_type, file_only=True)))
return valid
| [
"def",
"check_force_season_folders",
"(",
"pattern",
"=",
"None",
",",
"multi",
"=",
"None",
",",
"anime_type",
"=",
"None",
")",
":",
"if",
"(",
"pattern",
"is",
"None",
")",
":",
"pattern",
"=",
"sickbeard",
".",
"NAMING_PATTERN",
"if",
"(",
"anime_type"... | checks if the name can still be parsed if you strip off the folders to determine if we need to force season folders to be enabled or not . | train | false |
6,493 | def find_blade_root_dir(working_dir):
blade_root_dir = working_dir
if blade_root_dir.endswith('/'):
blade_root_dir = blade_root_dir[:(-1)]
while (blade_root_dir and (blade_root_dir != '/')):
if os.path.isfile(os.path.join(blade_root_dir, 'BLADE_ROOT')):
break
blade_root_dir = os.path.dirname(blade_root_dir)
if ((not blade_root_dir) or (blade_root_dir == '/')):
console.error_exit("Can't find the file 'BLADE_ROOT' in this or any upper directory.\nBlade need this file as a placeholder to locate the root source directory (aka the directory where you #include start from).\nYou should create it manually at the first time.")
return blade_root_dir
| [
"def",
"find_blade_root_dir",
"(",
"working_dir",
")",
":",
"blade_root_dir",
"=",
"working_dir",
"if",
"blade_root_dir",
".",
"endswith",
"(",
"'/'",
")",
":",
"blade_root_dir",
"=",
"blade_root_dir",
"[",
":",
"(",
"-",
"1",
")",
"]",
"while",
"(",
"blade_... | find_blade_root_dir to find the dir holds the blade_root file . | train | false |
6,494 | def normalize_version_number(version):
return _discover.normalize_version_number(version)
| [
"def",
"normalize_version_number",
"(",
"version",
")",
":",
"return",
"_discover",
".",
"normalize_version_number",
"(",
"version",
")"
] | turn a version representation into a tuple . | train | false |
6,496 | def bifid_square(key):
A = ''.join(uniq(''.join(key)))
n = (len(A) ** 0.5)
if (n != int(n)):
raise ValueError(('Length of alphabet (%s) is not a square number.' % len(A)))
n = int(n)
f = (lambda i, j: Symbol(A[((n * i) + j)]))
rv = Matrix(n, n, f)
return rv
| [
"def",
"bifid_square",
"(",
"key",
")",
":",
"A",
"=",
"''",
".",
"join",
"(",
"uniq",
"(",
"''",
".",
"join",
"(",
"key",
")",
")",
")",
"n",
"=",
"(",
"len",
"(",
"A",
")",
"**",
"0.5",
")",
"if",
"(",
"n",
"!=",
"int",
"(",
"n",
")",
... | return characters of key arranged in a square . | train | false |
6,497 | def _cross_val(data, est, cv, n_jobs):
try:
from sklearn.model_selection import cross_val_score
except ImportError:
from sklearn.cross_validation import cross_val_score
return np.mean(cross_val_score(est, data, cv=cv, n_jobs=n_jobs, scoring=_gaussian_loglik_scorer))
| [
"def",
"_cross_val",
"(",
"data",
",",
"est",
",",
"cv",
",",
"n_jobs",
")",
":",
"try",
":",
"from",
"sklearn",
".",
"model_selection",
"import",
"cross_val_score",
"except",
"ImportError",
":",
"from",
"sklearn",
".",
"cross_validation",
"import",
"cross_val... | helper to compute cross validation . | train | false |
6,498 | def es_to_datetime(value):
if ((not value) or isinstance(value, (date, datetime))):
return
if (len(value) == 26):
try:
return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S.%f')
except (TypeError, ValueError):
pass
elif (len(value) == 19):
try:
return datetime.strptime(value, '%Y-%m-%dT%H:%M:%S')
except (TypeError, ValueError):
pass
elif (len(value) == 10):
try:
return datetime.strptime(value, '%Y-%m-%d')
except (TypeError, ValueError):
pass
return value
| [
"def",
"es_to_datetime",
"(",
"value",
")",
":",
"if",
"(",
"(",
"not",
"value",
")",
"or",
"isinstance",
"(",
"value",
",",
"(",
"date",
",",
"datetime",
")",
")",
")",
":",
"return",
"if",
"(",
"len",
"(",
"value",
")",
"==",
"26",
")",
":",
... | returns a datetime given an elasticsearch date/datetime field . | train | false |
6,499 | def format_nmds_coords(samples, points, stress):
result = []
col_headers = [('NMDS' + str(aa)) for aa in range(1, (points.shape[1] + 1))]
result.append(('samples DCTB ' + ' DCTB '.join(col_headers)))
for (name, row) in zip(samples, points):
result.append(' DCTB '.join(([name] + map(str, row))))
result.append('')
result.append((((('stress DCTB ' + str(stress)) + ' DCTB ') + ('0 DCTB ' * (len(col_headers) - 2))) + '0'))
result.append(('% variation explained DCTB ' + ('0 DCTB ' * len(col_headers))))
return '\n'.join(result)
| [
"def",
"format_nmds_coords",
"(",
"samples",
",",
"points",
",",
"stress",
")",
":",
"result",
"=",
"[",
"]",
"col_headers",
"=",
"[",
"(",
"'NMDS'",
"+",
"str",
"(",
"aa",
")",
")",
"for",
"aa",
"in",
"range",
"(",
"1",
",",
"(",
"points",
".",
... | samples is list . | train | false |
6,500 | def get_cookie_header(jar, request):
r = MockRequest(request)
jar.add_cookie_header(r)
return r.get_new_headers().get('Cookie')
| [
"def",
"get_cookie_header",
"(",
"jar",
",",
"request",
")",
":",
"r",
"=",
"MockRequest",
"(",
"request",
")",
"jar",
".",
"add_cookie_header",
"(",
"r",
")",
"return",
"r",
".",
"get_new_headers",
"(",
")",
".",
"get",
"(",
"'Cookie'",
")"
] | produce an appropriate cookie header string to be sent with request . | train | true |
6,501 | def wrap_info(info):
if (info is None):
return None
else:
traceback = info[2]
assert isinstance(traceback, types.TracebackType)
traceback_id = id(traceback)
tracebacktable[traceback_id] = traceback
modified_info = (info[0], info[1], traceback_id)
return modified_info
| [
"def",
"wrap_info",
"(",
"info",
")",
":",
"if",
"(",
"info",
"is",
"None",
")",
":",
"return",
"None",
"else",
":",
"traceback",
"=",
"info",
"[",
"2",
"]",
"assert",
"isinstance",
"(",
"traceback",
",",
"types",
".",
"TracebackType",
")",
"traceback_... | replace info[2] . | train | false |
6,502 | def run_from_args(command, log_command_filter=identity):
return Effect(Run.from_args(command, log_command_filter=log_command_filter))
| [
"def",
"run_from_args",
"(",
"command",
",",
"log_command_filter",
"=",
"identity",
")",
":",
"return",
"Effect",
"(",
"Run",
".",
"from_args",
"(",
"command",
",",
"log_command_filter",
"=",
"log_command_filter",
")",
")"
] | run a command on a remote host . | train | false |
6,503 | def ISO8601Format(dt):
isoStr = dt.strftime('%Y-%m-%dT%H:%M:%S')
if dt.microsecond:
isoStr += ('.%06d' % dt.microsecond).rstrip('0')
if dt.tzinfo:
tz = dt.strftime('%z')
else:
if (time.daylight and time.localtime().tm_isdst):
utcOffset_minutes = ((- time.altzone) / 60)
else:
utcOffset_minutes = ((- time.timezone) / 60)
tz = ('%+.2d%.2d' % ((utcOffset_minutes / 60), (abs(utcOffset_minutes) % 60)))
if (tz == '+0000'):
return (isoStr + 'Z')
elif tz:
return (((isoStr + tz[:3]) + ':') + tz[3:])
else:
return (isoStr + '-00:00')
| [
"def",
"ISO8601Format",
"(",
"dt",
")",
":",
"isoStr",
"=",
"dt",
".",
"strftime",
"(",
"'%Y-%m-%dT%H:%M:%S'",
")",
"if",
"dt",
".",
"microsecond",
":",
"isoStr",
"+=",
"(",
"'.%06d'",
"%",
"dt",
".",
"microsecond",
")",
".",
"rstrip",
"(",
"'0'",
")",... | python datetime isoformat() has the following problems: - leave trailing 0 at the end of microseconds - tz print +00:00 instead of z - missing timezone offset for datetime without tzinfo . | train | true |
6,504 | def addGroupsToKey(server, activation_key, groups):
try:
(client, key) = _get_session(server)
except Exception as exc:
err_msg = 'Exception raised when connecting to spacewalk server ({0}): {1}'.format(server, exc)
log.error(err_msg)
return {'Error': err_msg}
all_groups = client.systemgroup.listAllGroups(key)
groupIds = []
for group in all_groups:
if (group['name'] in groups):
groupIds.append(group['id'])
if (client.activationkey.addServerGroups(key, activation_key, groupIds) == 1):
return {activation_key: groups}
else:
return {activation_key: 'Failed to add groups to activation key'}
| [
"def",
"addGroupsToKey",
"(",
"server",
",",
"activation_key",
",",
"groups",
")",
":",
"try",
":",
"(",
"client",
",",
"key",
")",
"=",
"_get_session",
"(",
"server",
")",
"except",
"Exception",
"as",
"exc",
":",
"err_msg",
"=",
"'Exception raised when conn... | add server groups to a activation key cli example: . | train | true |
6,505 | def order_property_names(query):
(filters, orders) = datastore_index.Normalize(query.filter_list(), query.order_list(), [])
orders = _GuessOrders(filters, orders)
return set((order.property() for order in orders if (order.property() != '__key__')))
| [
"def",
"order_property_names",
"(",
"query",
")",
":",
"(",
"filters",
",",
"orders",
")",
"=",
"datastore_index",
".",
"Normalize",
"(",
"query",
".",
"filter_list",
"(",
")",
",",
"query",
".",
"order_list",
"(",
")",
",",
"[",
"]",
")",
"orders",
"=... | generates a list of relevant order properties from the query . | train | false |
6,506 | def ts_add(ts, td):
return dt_to_ts((ts_to_dt(ts) + td))
| [
"def",
"ts_add",
"(",
"ts",
",",
"td",
")",
":",
"return",
"dt_to_ts",
"(",
"(",
"ts_to_dt",
"(",
"ts",
")",
"+",
"td",
")",
")"
] | allows a timedelta add operation on a string timestamp . | train | false |
6,508 | def _open_library(config):
dbpath = config['library'].as_filename()
try:
lib = library.Library(dbpath, config['directory'].as_filename(), get_path_formats(), get_replacements())
lib.get_item(0)
except (sqlite3.OperationalError, sqlite3.DatabaseError):
log.debug(traceback.format_exc())
raise UserError(u'database file {0} could not be opened'.format(util.displayable_path(dbpath)))
log.debug(u'library database: {0}\nlibrary directory: {1}'.format(util.displayable_path(lib.path), util.displayable_path(lib.directory)))
return lib
| [
"def",
"_open_library",
"(",
"config",
")",
":",
"dbpath",
"=",
"config",
"[",
"'library'",
"]",
".",
"as_filename",
"(",
")",
"try",
":",
"lib",
"=",
"library",
".",
"Library",
"(",
"dbpath",
",",
"config",
"[",
"'directory'",
"]",
".",
"as_filename",
... | create a new library instance from the configuration . | train | false |
6,509 | def to_sax(walker, handler):
handler.startDocument()
for (prefix, namespace) in prefix_mapping.items():
handler.startPrefixMapping(prefix, namespace)
for token in walker:
type = token[u'type']
if (type == u'Doctype'):
continue
elif (type in (u'StartTag', u'EmptyTag')):
attrs = AttributesNSImpl(token[u'data'], unadjustForeignAttributes)
handler.startElementNS((token[u'namespace'], token[u'name']), token[u'name'], attrs)
if (type == u'EmptyTag'):
handler.endElementNS((token[u'namespace'], token[u'name']), token[u'name'])
elif (type == u'EndTag'):
handler.endElementNS((token[u'namespace'], token[u'name']), token[u'name'])
elif (type in (u'Characters', u'SpaceCharacters')):
handler.characters(token[u'data'])
elif (type == u'Comment'):
pass
else:
assert False, u'Unknown token type'
for (prefix, namespace) in prefix_mapping.items():
handler.endPrefixMapping(prefix)
handler.endDocument()
| [
"def",
"to_sax",
"(",
"walker",
",",
"handler",
")",
":",
"handler",
".",
"startDocument",
"(",
")",
"for",
"(",
"prefix",
",",
"namespace",
")",
"in",
"prefix_mapping",
".",
"items",
"(",
")",
":",
"handler",
".",
"startPrefixMapping",
"(",
"prefix",
",... | call sax-like content handler based on treewalker walker . | train | false |
6,510 | def set_proxy_bypass(domains, network_service='Ethernet'):
servers_str = ' '.join(domains)
cmd = 'networksetup -setproxybypassdomains {0} {1}'.format(network_service, servers_str)
out = __salt__['cmd.run'](cmd)
return ('error' not in out)
| [
"def",
"set_proxy_bypass",
"(",
"domains",
",",
"network_service",
"=",
"'Ethernet'",
")",
":",
"servers_str",
"=",
"' '",
".",
"join",
"(",
"domains",
")",
"cmd",
"=",
"'networksetup -setproxybypassdomains {0} {1}'",
".",
"format",
"(",
"network_service",
",",
"s... | sets the domains that can bypass the proxy domains an array of domains allowed to bypass the proxy network_service the network service to apply the changes to . | train | true |
6,513 | def _ColonToEquals(node):
return ConvertNodes(node, QueryParser.HAS, QueryParser.EQ, '=')
| [
"def",
"_ColonToEquals",
"(",
"node",
")",
":",
"return",
"ConvertNodes",
"(",
"node",
",",
"QueryParser",
".",
"HAS",
",",
"QueryParser",
".",
"EQ",
",",
"'='",
")"
] | transform all has nodes into eq nodes . | train | false |
6,514 | def get_cache():
return requests.Session().cache
| [
"def",
"get_cache",
"(",
")",
":",
"return",
"requests",
".",
"Session",
"(",
")",
".",
"cache"
] | return the request cache named name . | train | false |
6,516 | @with_open_mode('r')
@with_sizes('medium')
def read_bytewise(f):
f.seek(0)
while f.read(1):
pass
| [
"@",
"with_open_mode",
"(",
"'r'",
")",
"@",
"with_sizes",
"(",
"'medium'",
")",
"def",
"read_bytewise",
"(",
"f",
")",
":",
"f",
".",
"seek",
"(",
"0",
")",
"while",
"f",
".",
"read",
"(",
"1",
")",
":",
"pass"
] | read one unit at a time . | train | false |
6,517 | def _nupicHyperSearchHasErrors(hyperSearchJob):
return False
| [
"def",
"_nupicHyperSearchHasErrors",
"(",
"hyperSearchJob",
")",
":",
"return",
"False"
] | check whether any experiments failed in our latest hypersearch parameters: hypersearchjob: _hypersearchjob instance; if none . | train | false |
6,518 | def skip_openpyxl_gt21(cls):
@classmethod
def setUpClass(cls):
_skip_if_no_openpyxl()
import openpyxl
ver = openpyxl.__version__
if (not ((LooseVersion(ver) >= LooseVersion('2.0.0')) and (LooseVersion(ver) < LooseVersion('2.2.0')))):
raise nose.SkipTest(('openpyxl %s >= 2.2' % str(ver)))
cls.setUpClass = setUpClass
return cls
| [
"def",
"skip_openpyxl_gt21",
"(",
"cls",
")",
":",
"@",
"classmethod",
"def",
"setUpClass",
"(",
"cls",
")",
":",
"_skip_if_no_openpyxl",
"(",
")",
"import",
"openpyxl",
"ver",
"=",
"openpyxl",
".",
"__version__",
"if",
"(",
"not",
"(",
"(",
"LooseVersion",
... | skip a testcase instance if openpyxl >= 2 . | train | false |
6,519 | def read_reject_parameters(fname):
try:
with open(fname, 'r') as f:
lines = f.readlines()
except:
raise ValueError(('Error while reading %s' % fname))
reject_names = ['gradReject', 'magReject', 'eegReject', 'eogReject', 'ecgReject']
reject_pynames = ['grad', 'mag', 'eeg', 'eog', 'ecg']
reject = dict()
for line in lines:
words = line.split()
if (words[0] in reject_names):
reject[reject_pynames[reject_names.index(words[0])]] = float(words[1])
return reject
| [
"def",
"read_reject_parameters",
"(",
"fname",
")",
":",
"try",
":",
"with",
"open",
"(",
"fname",
",",
"'r'",
")",
"as",
"f",
":",
"lines",
"=",
"f",
".",
"readlines",
"(",
")",
"except",
":",
"raise",
"ValueError",
"(",
"(",
"'Error while reading %s'",... | read rejection parameters from . | train | false |
6,520 | def getTransformedVector3s(matrixTetragrid, vector3s):
transformedVector3s = []
for vector3 in vector3s:
transformedVector3s.append(getVector3TransformedByMatrix(matrixTetragrid, vector3))
return transformedVector3s
| [
"def",
"getTransformedVector3s",
"(",
"matrixTetragrid",
",",
"vector3s",
")",
":",
"transformedVector3s",
"=",
"[",
"]",
"for",
"vector3",
"in",
"vector3s",
":",
"transformedVector3s",
".",
"append",
"(",
"getVector3TransformedByMatrix",
"(",
"matrixTetragrid",
",",
... | get the vector3s multiplied by a matrix . | train | false |
6,521 | def expm_cond(A, check_finite=True):
if check_finite:
A = np.asarray_chkfinite(A)
else:
A = np.asarray(A)
if ((len(A.shape) != 2) or (A.shape[0] != A.shape[1])):
raise ValueError('expected a square matrix')
X = scipy.linalg.expm(A)
K = expm_frechet_kronform(A, check_finite=False)
A_norm = scipy.linalg.norm(A, 'fro')
X_norm = scipy.linalg.norm(X, 'fro')
K_norm = scipy.linalg.norm(K, 2)
kappa = ((K_norm * A_norm) / X_norm)
return kappa
| [
"def",
"expm_cond",
"(",
"A",
",",
"check_finite",
"=",
"True",
")",
":",
"if",
"check_finite",
":",
"A",
"=",
"np",
".",
"asarray_chkfinite",
"(",
"A",
")",
"else",
":",
"A",
"=",
"np",
".",
"asarray",
"(",
"A",
")",
"if",
"(",
"(",
"len",
"(",
... | relative condition number of the matrix exponential in the frobenius norm . | train | false |
6,524 | def getCylindricalByRadians(azimuthRadians, radius=1.0, z=0.0):
polar = (radius * euclidean.getWiddershinsUnitPolar(azimuthRadians))
return Vector3(polar.real, polar.imag, z)
| [
"def",
"getCylindricalByRadians",
"(",
"azimuthRadians",
",",
"radius",
"=",
"1.0",
",",
"z",
"=",
"0.0",
")",
":",
"polar",
"=",
"(",
"radius",
"*",
"euclidean",
".",
"getWiddershinsUnitPolar",
"(",
"azimuthRadians",
")",
")",
"return",
"Vector3",
"(",
"pol... | get the cylindrical vector3 by radians . | train | false |
6,525 | def model_unpickle(model, attrs):
cls = deferred_class_factory(model, attrs)
return cls.__new__(cls)
| [
"def",
"model_unpickle",
"(",
"model",
",",
"attrs",
")",
":",
"cls",
"=",
"deferred_class_factory",
"(",
"model",
",",
"attrs",
")",
"return",
"cls",
".",
"__new__",
"(",
"cls",
")"
] | used to unpickle model subclasses with deferred fields . | train | false |
6,526 | def sampling_E(expr, given_condition=None, numsamples=1, evalf=True, **kwargs):
samples = sample_iter(expr, given_condition, numsamples=numsamples, **kwargs)
result = (Add(*list(samples)) / numsamples)
if evalf:
return result.evalf()
else:
return result
| [
"def",
"sampling_E",
"(",
"expr",
",",
"given_condition",
"=",
"None",
",",
"numsamples",
"=",
"1",
",",
"evalf",
"=",
"True",
",",
"**",
"kwargs",
")",
":",
"samples",
"=",
"sample_iter",
"(",
"expr",
",",
"given_condition",
",",
"numsamples",
"=",
"num... | sampling version of e see also p sampling_p sampling_density . | train | false |
6,527 | def matchStrength(x, y):
return sum(((xi == yi) for (xi, yi) in zip(x, y)))
| [
"def",
"matchStrength",
"(",
"x",
",",
"y",
")",
":",
"return",
"sum",
"(",
"(",
"(",
"xi",
"==",
"yi",
")",
"for",
"(",
"xi",
",",
"yi",
")",
"in",
"zip",
"(",
"x",
",",
"y",
")",
")",
")"
] | compute the match strength for the individual *x* on the string *y* . | train | false |
6,528 | @pytest.mark.django_db
def test_add_store_bad_path(po_directory, english):
fs_path = '/some/fs/example.po'
project = ProjectDBFactory(source_language=english)
language = LanguageDBFactory()
tp = TranslationProjectFactory(project=project, language=language)
conf = config.get(project.__class__, instance=project)
conf.set_config('pootle_fs.fs_type', 'localfs')
conf.set_config('pootle_fs.fs_url', 'foo')
store = StoreDBFactory(translation_project=tp, parent=tp.directory, name='example_store.po')
with pytest.raises(ValidationError):
StoreFS.objects.create(store=store, pootle_path='/some/other/path.po', path=fs_path)
| [
"@",
"pytest",
".",
"mark",
".",
"django_db",
"def",
"test_add_store_bad_path",
"(",
"po_directory",
",",
"english",
")",
":",
"fs_path",
"=",
"'/some/fs/example.po'",
"project",
"=",
"ProjectDBFactory",
"(",
"source_language",
"=",
"english",
")",
"language",
"="... | try to create a store_fs where pootle_path and store . | train | false |
6,531 | def render_plugin(values):
env = jinja2.Environment(loader=jinja2.FileSystemLoader(os.path.join(os.path.dirname(__file__), 'templates')), auto_reload=False, keep_trailing_newline=True, autoescape=True)
template = env.get_template('new_plugin.py.tmpl')
return template.render(**values)
| [
"def",
"render_plugin",
"(",
"values",
")",
":",
"env",
"=",
"jinja2",
".",
"Environment",
"(",
"loader",
"=",
"jinja2",
".",
"FileSystemLoader",
"(",
"os",
".",
"path",
".",
"join",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"__file__",
")",
",",
... | render the jinja template for the plugin with the given values . | train | false |
6,533 | @utils.service_type('monitor')
def do_type_list(cs, args):
vtypes = cs.monitor_types.list()
_print_monitor_type_list(vtypes)
| [
"@",
"utils",
".",
"service_type",
"(",
"'monitor'",
")",
"def",
"do_type_list",
"(",
"cs",
",",
"args",
")",
":",
"vtypes",
"=",
"cs",
".",
"monitor_types",
".",
"list",
"(",
")",
"_print_monitor_type_list",
"(",
"vtypes",
")"
] | print a list of available monitor types . | train | false |
6,534 | def distribution():
return s3_rest_controller()
| [
"def",
"distribution",
"(",
")",
":",
"return",
"s3_rest_controller",
"(",
")"
] | mock android sdk distribution . | train | false |
6,535 | def _key2bin(s):
kl = map((lambda x: ord(x)), s)
kl = map((lambda x: (binary[(x / 16)] + binary[(x & 15)])), kl)
return ''.join(kl)
| [
"def",
"_key2bin",
"(",
"s",
")",
":",
"kl",
"=",
"map",
"(",
"(",
"lambda",
"x",
":",
"ord",
"(",
"x",
")",
")",
",",
"s",
")",
"kl",
"=",
"map",
"(",
"(",
"lambda",
"x",
":",
"(",
"binary",
"[",
"(",
"x",
"/",
"16",
")",
"]",
"+",
"bi... | convert a key into a string of binary digits . | train | false |
6,536 | def test_platform_validator():
hass = None
try:
hass = get_test_home_assistant()
schema = vol.Schema(cv.platform_validator('light'))
with pytest.raises(vol.MultipleInvalid):
schema('platform_that_does_not_exist')
schema('hue')
finally:
if (hass is not None):
hass.stop()
| [
"def",
"test_platform_validator",
"(",
")",
":",
"hass",
"=",
"None",
"try",
":",
"hass",
"=",
"get_test_home_assistant",
"(",
")",
"schema",
"=",
"vol",
".",
"Schema",
"(",
"cv",
".",
"platform_validator",
"(",
"'light'",
")",
")",
"with",
"pytest",
".",
... | test platform validation . | train | false |
6,538 | def as_float_array(X, copy=True, force_all_finite=True):
if (isinstance(X, np.matrix) or ((not isinstance(X, np.ndarray)) and (not sp.issparse(X)))):
return check_array(X, ['csr', 'csc', 'coo'], dtype=np.float64, copy=copy, force_all_finite=force_all_finite, ensure_2d=False)
elif (sp.issparse(X) and (X.dtype in [np.float32, np.float64])):
return (X.copy() if copy else X)
elif (X.dtype in [np.float32, np.float64]):
return (X.copy(('F' if X.flags['F_CONTIGUOUS'] else 'C')) if copy else X)
else:
return X.astype((np.float32 if (X.dtype == np.int32) else np.float64))
| [
"def",
"as_float_array",
"(",
"X",
",",
"copy",
"=",
"True",
",",
"force_all_finite",
"=",
"True",
")",
":",
"if",
"(",
"isinstance",
"(",
"X",
",",
"np",
".",
"matrix",
")",
"or",
"(",
"(",
"not",
"isinstance",
"(",
"X",
",",
"np",
".",
"ndarray",... | converts an array-like to an array of floats the new dtype will be np . | train | true |
6,540 | def timelimit(timeout):
def _1(function):
def _2(*args, **kw):
class Dispatch(threading.Thread, ):
def __init__(self):
threading.Thread.__init__(self)
self.result = None
self.error = None
self.setDaemon(True)
self.start()
def run(self):
try:
self.result = function(*args, **kw)
except:
self.error = sys.exc_info()
c = Dispatch()
c.join(timeout)
if c.isAlive():
raise TimeoutError()
if c.error:
raise c.error[0](c.error[1])
return c.result
return _2
return _1
| [
"def",
"timelimit",
"(",
"timeout",
")",
":",
"def",
"_1",
"(",
"function",
")",
":",
"def",
"_2",
"(",
"*",
"args",
",",
"**",
"kw",
")",
":",
"class",
"Dispatch",
"(",
"threading",
".",
"Thread",
",",
")",
":",
"def",
"__init__",
"(",
"self",
"... | a decorator to limit a function to timeout seconds . | train | true |
6,541 | def upgrade_to_float(*types):
conv = {bool: float32, int8: float32, int16: float32, int32: float64, int64: float64, uint8: float32, uint16: float32, uint32: float64, uint64: float64}
return (get_scalar_type(Scalar.upcast(*[conv.get(type, type) for type in types])),)
| [
"def",
"upgrade_to_float",
"(",
"*",
"types",
")",
":",
"conv",
"=",
"{",
"bool",
":",
"float32",
",",
"int8",
":",
"float32",
",",
"int16",
":",
"float32",
",",
"int32",
":",
"float64",
",",
"int64",
":",
"float64",
",",
"uint8",
":",
"float32",
","... | upgrade any int types to float32 or float64 to avoid losing precision . | train | false |
6,542 | def SetFilesProperty(output, variable, property_name, values, sep):
output.write('set_source_files_properties(')
WriteVariable(output, variable)
output.write(' PROPERTIES ')
output.write(property_name)
output.write(' "')
for value in values:
output.write(CMakeStringEscape(value))
output.write(sep)
output.write('")\n')
| [
"def",
"SetFilesProperty",
"(",
"output",
",",
"variable",
",",
"property_name",
",",
"values",
",",
"sep",
")",
":",
"output",
".",
"write",
"(",
"'set_source_files_properties('",
")",
"WriteVariable",
"(",
"output",
",",
"variable",
")",
"output",
".",
"writ... | given a set of source files . | train | false |
6,544 | def fixup_link(link, target_blank=True):
if target_blank:
link.set('target', '_blank')
link.set('title', url_filename(link.get('href')))
| [
"def",
"fixup_link",
"(",
"link",
",",
"target_blank",
"=",
"True",
")",
":",
"if",
"target_blank",
":",
"link",
".",
"set",
"(",
"'target'",
",",
"'_blank'",
")",
"link",
".",
"set",
"(",
"'title'",
",",
"url_filename",
"(",
"link",
".",
"get",
"(",
... | set certain attributes we want on every link . | train | false |
6,545 | def _item_path(item):
try:
path = item.path
except AttributeError:
path = u''
return path
| [
"def",
"_item_path",
"(",
"item",
")",
":",
"try",
":",
"path",
"=",
"item",
".",
"path",
"except",
"AttributeError",
":",
"path",
"=",
"u''",
"return",
"path"
] | return the items path . | train | false |
6,546 | def draw_values(params, point=None):
givens = {}
for param in params:
if hasattr(param, 'name'):
named_nodes = get_named_nodes(param)
if (param.name in named_nodes):
named_nodes.pop(param.name)
for (name, node) in named_nodes.items():
if (not isinstance(node, (tt.sharedvar.TensorSharedVariable, tt.TensorConstant))):
givens[name] = (node, draw_value(node, point=point))
values = [None for _ in params]
for (i, param) in enumerate(params):
values[i] = np.atleast_1d(draw_value(param, point=point, givens=givens.values()))
if (len(values) == 1):
return values[0]
else:
return values
| [
"def",
"draw_values",
"(",
"params",
",",
"point",
"=",
"None",
")",
":",
"givens",
"=",
"{",
"}",
"for",
"param",
"in",
"params",
":",
"if",
"hasattr",
"(",
"param",
",",
"'name'",
")",
":",
"named_nodes",
"=",
"get_named_nodes",
"(",
"param",
")",
... | draw parameter values . | train | false |
6,547 | def topic_children_documents_link(obj):
count = obj.children.count()
if (not count):
return ''
link = ('%s?%s' % (reverse('admin:wiki_document_changelist', args=[]), ('parent_topic__exact=%s' % obj.id)))
what = (((count == 1) and 'child') or 'children')
return ('<a href="%s">%s %s</a>' % (link, count, what))
| [
"def",
"topic_children_documents_link",
"(",
"obj",
")",
":",
"count",
"=",
"obj",
".",
"children",
".",
"count",
"(",
")",
"if",
"(",
"not",
"count",
")",
":",
"return",
"''",
"link",
"=",
"(",
"'%s?%s'",
"%",
"(",
"reverse",
"(",
"'admin:wiki_document_... | html link to a list of child documents . | train | false |
6,548 | def check_or_die(command):
if (command is None):
raise CommandNotFoundError("'None' is not a valid command.")
if (not which(command)):
raise CommandNotFoundError("'{0}' is not in the path".format(command))
| [
"def",
"check_or_die",
"(",
"command",
")",
":",
"if",
"(",
"command",
"is",
"None",
")",
":",
"raise",
"CommandNotFoundError",
"(",
"\"'None' is not a valid command.\"",
")",
"if",
"(",
"not",
"which",
"(",
"command",
")",
")",
":",
"raise",
"CommandNotFoundE... | simple convenience function for modules to use for gracefully blowing up if a required tool is not available in the system path . | train | false |
6,549 | def remove_user(user):
user_pre_delete.send(instance=user, sender=user.__class__)
user.username = u'deleted-{0}'.format(user.pk)
while User.objects.filter(username=user.username).exists():
user.username = u'deleted-{0}-{1}'.format(user.pk, binascii.b2a_hex(os.urandom(5)))
user.first_name = u'Deleted User'
user.last_name = u''
user.email = u'noreply@weblate.org'
user.is_active = False
user.set_unusable_password()
user.save()
user.social_auth.all().delete()
| [
"def",
"remove_user",
"(",
"user",
")",
":",
"user_pre_delete",
".",
"send",
"(",
"instance",
"=",
"user",
",",
"sender",
"=",
"user",
".",
"__class__",
")",
"user",
".",
"username",
"=",
"u'deleted-{0}'",
".",
"format",
"(",
"user",
".",
"pk",
")",
"w... | remove user from conference . | train | false |
6,550 | def underscore_memoization(func):
name = ('_' + func.__name__)
def wrapper(self):
try:
return getattr(self, name)
except AttributeError:
result = func(self)
if inspect.isgenerator(result):
result = list(result)
setattr(self, name, result)
return result
return wrapper
| [
"def",
"underscore_memoization",
"(",
"func",
")",
":",
"name",
"=",
"(",
"'_'",
"+",
"func",
".",
"__name__",
")",
"def",
"wrapper",
"(",
"self",
")",
":",
"try",
":",
"return",
"getattr",
"(",
"self",
",",
"name",
")",
"except",
"AttributeError",
":"... | decorator for methods:: class a: def x: if self . | train | false |
6,551 | def estimate_total_entities(session, db_master, keyname):
query = SimpleStatement('SELECT COUNT(*) FROM "{}"'.format(dbconstants.APP_ENTITY_TABLE), consistency_level=ConsistencyLevel.ONE)
try:
rows = session.execute(query)[0].count
return str((rows / len(dbconstants.APP_ENTITY_SCHEMA)))
except dbconstants.TRANSIENT_CASSANDRA_ERRORS:
stats_cmd = '{nodetool} cfstats {keyspace}.{table}'.format(nodetool=cassandra_interface.NODE_TOOL, keyspace=cassandra_interface.KEYSPACE, table=dbconstants.APP_ENTITY_TABLE)
stats = utils.ssh(db_master, keyname, stats_cmd, method=subprocess.check_output)
for line in stats.splitlines():
if ('Number of keys (estimate)' in line):
return '{} (estimate)'.format(line.split()[(-1)])
raise dbconstants.AppScaleDBError('Unable to estimate total entities.')
| [
"def",
"estimate_total_entities",
"(",
"session",
",",
"db_master",
",",
"keyname",
")",
":",
"query",
"=",
"SimpleStatement",
"(",
"'SELECT COUNT(*) FROM \"{}\"'",
".",
"format",
"(",
"dbconstants",
".",
"APP_ENTITY_TABLE",
")",
",",
"consistency_level",
"=",
"Cons... | estimate the total number of entities . | train | false |
6,552 | def wrap_conf_type(f):
def wrapper(conf_path, *args, **kwargs):
if os.path.isdir(conf_path):
conf_type = 'config_dir'
else:
conf_type = 'config'
conf_uri = ('%s:%s' % (conf_type, conf_path))
return f(conf_uri, *args, **kwargs)
return wrapper
| [
"def",
"wrap_conf_type",
"(",
"f",
")",
":",
"def",
"wrapper",
"(",
"conf_path",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"conf_path",
")",
":",
"conf_type",
"=",
"'config_dir'",
"else",
":",
"conf_... | wrap a function whos first argument is a paste . | train | false |
6,553 | def deduce_helpful_msg(req):
msg = ''
if os.path.exists(req):
msg = ' It does exist.'
try:
with open(req, 'r') as fp:
parse_requirements(fp.read()).next()
msg += ((((' The argument you provided ' + ('(%s) appears to be a' % req)) + ' requirements file. If that is the') + " case, use the '-r' flag to install") + ' the packages specified within it.')
except RequirementParseError:
logger.debug(("Cannot parse '%s' as requirements file" % req), exc_info=1)
else:
msg += (" File '%s' does not exist." % req)
return msg
| [
"def",
"deduce_helpful_msg",
"(",
"req",
")",
":",
"msg",
"=",
"''",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"req",
")",
":",
"msg",
"=",
"' It does exist.'",
"try",
":",
"with",
"open",
"(",
"req",
",",
"'r'",
")",
"as",
"fp",
":",
"parse_req... | returns helpful msg in case requirements file does not exist . | train | true |
6,554 | def _get_axis(indexes):
ndim = len(indexes)
indexes = [(slice(None, None) if (i is None) else [0]) for i in indexes]
x = np.empty(((2,) * ndim))
x2 = x[tuple(indexes)]
return x2.shape.index(1)
| [
"def",
"_get_axis",
"(",
"indexes",
")",
":",
"ndim",
"=",
"len",
"(",
"indexes",
")",
"indexes",
"=",
"[",
"(",
"slice",
"(",
"None",
",",
"None",
")",
"if",
"(",
"i",
"is",
"None",
")",
"else",
"[",
"0",
"]",
")",
"for",
"i",
"in",
"indexes",... | get axis along which point-wise slicing results lie this is mostly a hack because i cant figure out numpys rule on this and cant be bothered to go reading . | train | false |
6,555 | def get_imdb(name):
if (not __sets.has_key(name)):
raise KeyError('Unknown dataset: {}'.format(name))
return __sets[name]()
| [
"def",
"get_imdb",
"(",
"name",
")",
":",
"if",
"(",
"not",
"__sets",
".",
"has_key",
"(",
"name",
")",
")",
":",
"raise",
"KeyError",
"(",
"'Unknown dataset: {}'",
".",
"format",
"(",
"name",
")",
")",
"return",
"__sets",
"[",
"name",
"]",
"(",
")"
... | get an imdb by name . | train | false |
6,556 | def leftordered(M):
l = list(M.T)
l.sort(key=tuple)
return array(l)[::(-1)].T
| [
"def",
"leftordered",
"(",
"M",
")",
":",
"l",
"=",
"list",
"(",
"M",
".",
"T",
")",
"l",
".",
"sort",
"(",
"key",
"=",
"tuple",
")",
"return",
"array",
"(",
"l",
")",
"[",
":",
":",
"(",
"-",
"1",
")",
"]",
".",
"T"
] | returns the given matrix in left-ordered-form . | train | false |
6,557 | def credsfromfile(creds_file=None, subdir=None, verbose=False):
return Authenticate().load_creds(creds_file=creds_file, subdir=subdir, verbose=verbose)
| [
"def",
"credsfromfile",
"(",
"creds_file",
"=",
"None",
",",
"subdir",
"=",
"None",
",",
"verbose",
"=",
"False",
")",
":",
"return",
"Authenticate",
"(",
")",
".",
"load_creds",
"(",
"creds_file",
"=",
"creds_file",
",",
"subdir",
"=",
"subdir",
",",
"v... | convenience function for authentication . | train | false |
6,558 | @subscriber(ResourceChanged, for_resources=('collection',), for_actions=(ACTIONS.DELETE,))
def on_collections_deleted(event):
storage = event.request.registry.storage
permission = event.request.registry.permission
for change in event.impacted_records:
collection = change['old']
bucket_id = event.payload['bucket_id']
parent_id = utils.instance_uri(event.request, 'collection', bucket_id=bucket_id, id=collection['id'])
storage.delete_all(collection_id='record', parent_id=parent_id, with_deleted=False)
storage.purge_deleted(collection_id='record', parent_id=parent_id)
permission.delete_object_permissions((parent_id + '*'))
| [
"@",
"subscriber",
"(",
"ResourceChanged",
",",
"for_resources",
"=",
"(",
"'collection'",
",",
")",
",",
"for_actions",
"=",
"(",
"ACTIONS",
".",
"DELETE",
",",
")",
")",
"def",
"on_collections_deleted",
"(",
"event",
")",
":",
"storage",
"=",
"event",
".... | some collections were deleted . | train | false |
6,559 | def get_webdefault_xml(sdk_root=None):
if (not sdk_root):
sdk_root = _SDK_ROOT
with open(os.path.join(sdk_root, _WEBDEFAULT_XML_PATH)) as f:
return f.read()
| [
"def",
"get_webdefault_xml",
"(",
"sdk_root",
"=",
"None",
")",
":",
"if",
"(",
"not",
"sdk_root",
")",
":",
"sdk_root",
"=",
"_SDK_ROOT",
"with",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"sdk_root",
",",
"_WEBDEFAULT_XML_PATH",
")",
")",
"as",
... | returns the contents of webdefault . | train | false |
6,560 | def test_batch_normalization_image_size_setter():
bn = BatchNormalization()
bn.image_size = (5, 4)
assert (bn.input_dim == (None, 5, 4))
bn.image_size = (4, 5)
assert (bn.input_dim == (None, 4, 5))
| [
"def",
"test_batch_normalization_image_size_setter",
"(",
")",
":",
"bn",
"=",
"BatchNormalization",
"(",
")",
"bn",
".",
"image_size",
"=",
"(",
"5",
",",
"4",
")",
"assert",
"(",
"bn",
".",
"input_dim",
"==",
"(",
"None",
",",
"5",
",",
"4",
")",
")"... | test that setting image_size on a batchnormalization works . | train | false |
6,561 | def get_siblings(x, collection=None):
parents = get_parents(x, collection)
siblings = set([])
for parent in parents:
siblings.update(get_children(parent, collection))
siblings.discard(x)
return list(siblings)
| [
"def",
"get_siblings",
"(",
"x",
",",
"collection",
"=",
"None",
")",
":",
"parents",
"=",
"get_parents",
"(",
"x",
",",
"collection",
")",
"siblings",
"=",
"set",
"(",
"[",
"]",
")",
"for",
"parent",
"in",
"parents",
":",
"siblings",
".",
"update",
... | get sibling random variables of input . | train | false |
6,562 | def sig_stars(p):
if (p < 0.001):
return '***'
elif (p < 0.01):
return '**'
elif (p < 0.05):
return '*'
elif (p < 0.1):
return '.'
return ''
| [
"def",
"sig_stars",
"(",
"p",
")",
":",
"if",
"(",
"p",
"<",
"0.001",
")",
":",
"return",
"'***'",
"elif",
"(",
"p",
"<",
"0.01",
")",
":",
"return",
"'**'",
"elif",
"(",
"p",
"<",
"0.05",
")",
":",
"return",
"'*'",
"elif",
"(",
"p",
"<",
"0.... | return a r-style significance string corresponding to p values . | train | false |
6,563 | def recreate_instances_in_mig(mig):
changed = False
return_data = []
actions_filter = ['RECREATING']
if mig.recreate_instances():
changed = True
return_data = _get_instance_list(mig, filter_list=actions_filter)
return (changed, return_data)
| [
"def",
"recreate_instances_in_mig",
"(",
"mig",
")",
":",
"changed",
"=",
"False",
"return_data",
"=",
"[",
"]",
"actions_filter",
"=",
"[",
"'RECREATING'",
"]",
"if",
"mig",
".",
"recreate_instances",
"(",
")",
":",
"changed",
"=",
"True",
"return_data",
"=... | recreate the instances for a managed instance group . | train | false |
6,564 | def ylabel(s, *args, **kwargs):
return gca().set_ylabel(s, *args, **kwargs)
| [
"def",
"ylabel",
"(",
"s",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"return",
"gca",
"(",
")",
".",
"set_ylabel",
"(",
"s",
",",
"*",
"args",
",",
"**",
"kwargs",
")"
] | set the *y* axis label of the current axis to *s* . | train | false |
6,565 | def load_handlers(config, handler_names):
handlers = []
if isinstance(handler_names, basestring):
handler_names = [handler_names]
for handler in handler_names:
logger.debug('Loading Handler %s', handler)
try:
cls = load_dynamic_class(handler, Handler)
cls_name = cls.__name__
handler_config = configobj.ConfigObj()
handler_config.merge(config['handlers']['default'])
if (cls_name in config['handlers']):
handler_config.merge(config['handlers'][cls_name])
if ('handlers_config_path' in config['server']):
configfile = (os.path.join(config['server']['handlers_config_path'], cls_name) + '.conf')
if os.path.exists(configfile):
handler_config.merge(configobj.ConfigObj(configfile))
h = cls(handler_config)
handlers.append(h)
except (ImportError, SyntaxError):
logger.warning('Failed to load handler %s. %s', handler, traceback.format_exc())
continue
return handlers
| [
"def",
"load_handlers",
"(",
"config",
",",
"handler_names",
")",
":",
"handlers",
"=",
"[",
"]",
"if",
"isinstance",
"(",
"handler_names",
",",
"basestring",
")",
":",
"handler_names",
"=",
"[",
"handler_names",
"]",
"for",
"handler",
"in",
"handler_names",
... | load handlers . | train | true |
6,566 | @celery.task
def receive_async(text, connection_id, message_id, fields):
from rapidsms.models import Connection
from rapidsms.router import get_router
logger.debug('receive_async: %s', text)
router = get_router()
connection = Connection.objects.select_related().get(pk=connection_id)
message = router.new_incoming_message(text=text, connections=[connection], id_=message_id, fields=fields)
try:
router.process_incoming(message)
except Exception:
logger.exception('Exception processing incoming message')
raise
| [
"@",
"celery",
".",
"task",
"def",
"receive_async",
"(",
"text",
",",
"connection_id",
",",
"message_id",
",",
"fields",
")",
":",
"from",
"rapidsms",
".",
"models",
"import",
"Connection",
"from",
"rapidsms",
".",
"router",
"import",
"get_router",
"logger",
... | task used to send inbound message through router phases . | train | false |
6,567 | @task(base=BaseInstructorTask)
def enrollment_report_features_csv(entry_id, xmodule_instance_args):
action_name = ugettext_noop('generating_enrollment_report')
task_fn = partial(upload_enrollment_report, xmodule_instance_args)
return run_main_task(entry_id, task_fn, action_name)
| [
"@",
"task",
"(",
"base",
"=",
"BaseInstructorTask",
")",
"def",
"enrollment_report_features_csv",
"(",
"entry_id",
",",
"xmodule_instance_args",
")",
":",
"action_name",
"=",
"ugettext_noop",
"(",
"'generating_enrollment_report'",
")",
"task_fn",
"=",
"partial",
"(",... | compute student profile information for a course and upload the csv to an s3 bucket for download . | train | false |
6,569 | def printhdr(file):
hdr = gethdr(open(file, 'r'))
(data_size, encoding, sample_rate, channels, info) = hdr
while (info[(-1):] == '\x00'):
info = info[:(-1)]
print 'File name: ', file
print 'Data size: ', data_size
print 'Encoding: ', encoding
print 'Sample rate:', sample_rate
print 'Channels: ', channels
print 'Info: ', repr(info)
| [
"def",
"printhdr",
"(",
"file",
")",
":",
"hdr",
"=",
"gethdr",
"(",
"open",
"(",
"file",
",",
"'r'",
")",
")",
"(",
"data_size",
",",
"encoding",
",",
"sample_rate",
",",
"channels",
",",
"info",
")",
"=",
"hdr",
"while",
"(",
"info",
"[",
"(",
... | read and print the sound header of a named file . | train | false |
6,574 | def identity(x):
return x
| [
"def",
"identity",
"(",
"x",
")",
":",
"return",
"x"
] | returns a 2-d identity array . | train | false |
6,576 | def sample_func(v):
return (v + v)
| [
"def",
"sample_func",
"(",
"v",
")",
":",
"return",
"(",
"v",
"+",
"v",
")"
] | blah blah . | train | false |
6,577 | def bitbucket_webhook_helper(data):
repos = [(repo % {'full_name': data['repository']['full_name']}) for repo in BITBUCKET_REPOS]
return {'service_long_name': 'Bitbucket', 'repo_url': data['repository']['links']['html']['href'], 'repos': repos, 'branch': data['push']['changes'][(-1)]['new']['name']}
| [
"def",
"bitbucket_webhook_helper",
"(",
"data",
")",
":",
"repos",
"=",
"[",
"(",
"repo",
"%",
"{",
"'full_name'",
":",
"data",
"[",
"'repository'",
"]",
"[",
"'full_name'",
"]",
"}",
")",
"for",
"repo",
"in",
"BITBUCKET_REPOS",
"]",
"return",
"{",
"'ser... | api to handle webhooks from bitbucket . | train | false |
6,578 | def _split_repo_str(repo):
split = sourceslist.SourceEntry(repo)
return (split.type, split.uri, split.dist, split.comps)
| [
"def",
"_split_repo_str",
"(",
"repo",
")",
":",
"split",
"=",
"sourceslist",
".",
"SourceEntry",
"(",
"repo",
")",
"return",
"(",
"split",
".",
"type",
",",
"split",
".",
"uri",
",",
"split",
".",
"dist",
",",
"split",
".",
"comps",
")"
] | return apt source entry as a tuple . | train | true |
6,579 | def apt_get_install(args, sudo=False):
return _from_args(sudo)((['apt-get', '-y', 'install'] + args))
| [
"def",
"apt_get_install",
"(",
"args",
",",
"sudo",
"=",
"False",
")",
":",
"return",
"_from_args",
"(",
"sudo",
")",
"(",
"(",
"[",
"'apt-get'",
",",
"'-y'",
",",
"'install'",
"]",
"+",
"args",
")",
")"
] | install a package with apt-get . | train | false |
6,580 | def test_ctor(refresher):
assert (len(refresher.refreshers) > 0)
actual_handlers = list(refresher.refreshers.keys())
expected_handlers = ['schemata', 'tables', 'views', 'functions', 'types', 'databases', 'casing']
assert (expected_handlers == actual_handlers)
| [
"def",
"test_ctor",
"(",
"refresher",
")",
":",
"assert",
"(",
"len",
"(",
"refresher",
".",
"refreshers",
")",
">",
"0",
")",
"actual_handlers",
"=",
"list",
"(",
"refresher",
".",
"refreshers",
".",
"keys",
"(",
")",
")",
"expected_handlers",
"=",
"[",... | refresher object should contain a few handlers . | train | false |
6,581 | def resync(hive, hive_names, timeout=2, max_attempts=5):
for hostname in hive_names:
if (hive[hostname] is not None):
for attempts in range(0, max_attempts):
if (not hive[hostname].prompt(timeout=timeout)):
break
| [
"def",
"resync",
"(",
"hive",
",",
"hive_names",
",",
"timeout",
"=",
"2",
",",
"max_attempts",
"=",
"5",
")",
":",
"for",
"hostname",
"in",
"hive_names",
":",
"if",
"(",
"hive",
"[",
"hostname",
"]",
"is",
"not",
"None",
")",
":",
"for",
"attempts",... | this waits for the shell prompt for each host in an effort to try to get them all to the same state . | train | false |
6,582 | @frappe.whitelist()
def getdoc(doctype, name, user=None):
if (not (doctype and name)):
raise Exception, u'doctype and name required!'
if (not name):
name = doctype
if (not frappe.db.exists(doctype, name)):
return []
try:
doc = frappe.get_doc(doctype, name)
run_onload(doc)
if (not doc.has_permission(u'read')):
raise frappe.PermissionError, (u'read', doctype, name)
doc.apply_fieldlevel_read_permissions()
get_docinfo(doc)
except Exception:
frappe.errprint(frappe.utils.get_traceback())
frappe.msgprint(_(u'Did not load'))
raise
if (doc and (not name.startswith(u'_'))):
frappe.get_user().update_recent(doctype, name)
doc.add_seen()
frappe.response.docs.append(doc)
| [
"@",
"frappe",
".",
"whitelist",
"(",
")",
"def",
"getdoc",
"(",
"doctype",
",",
"name",
",",
"user",
"=",
"None",
")",
":",
"if",
"(",
"not",
"(",
"doctype",
"and",
"name",
")",
")",
":",
"raise",
"Exception",
",",
"u'doctype and name required!'",
"if... | get the doc string or comments for an object . | train | false |
6,583 | def _make_evokeds(coefs, conds, cond_length, tmin_s, tmax_s, info):
evokeds = dict()
cumul = 0
for cond in conds:
(tmin_, tmax_) = (tmin_s[cond], tmax_s[cond])
evokeds[cond] = EvokedArray(coefs[:, cumul:((cumul + tmax_) - tmin_)], info=info, comment=cond, tmin=(tmin_ / float(info['sfreq'])), nave=cond_length[cond], kind='average')
cumul += (tmax_ - tmin_)
return evokeds
| [
"def",
"_make_evokeds",
"(",
"coefs",
",",
"conds",
",",
"cond_length",
",",
"tmin_s",
",",
"tmax_s",
",",
"info",
")",
":",
"evokeds",
"=",
"dict",
"(",
")",
"cumul",
"=",
"0",
"for",
"cond",
"in",
"conds",
":",
"(",
"tmin_",
",",
"tmax_",
")",
"=... | create a dictionary of evoked objects . | train | false |
6,585 | def site_data_dir(appname=None, appauthor=None, version=None, multipath=False):
if (sys.platform == 'win32'):
if (appauthor is None):
appauthor = appname
path = os.path.normpath(_get_win_folder('CSIDL_COMMON_APPDATA'))
if appname:
path = os.path.join(path, appauthor, appname)
elif (sys.platform == 'darwin'):
path = os.path.expanduser('/Library/Application Support')
if appname:
path = os.path.join(path, appname)
else:
path = os.getenv('XDG_DATA_DIRS', os.pathsep.join(['/usr/local/share', '/usr/share']))
pathlist = [os.path.expanduser(x.rstrip(os.sep)) for x in path.split(os.pathsep)]
if appname:
if version:
appname = os.path.join(appname, version)
pathlist = [os.sep.join([x, appname]) for x in pathlist]
if multipath:
path = os.pathsep.join(pathlist)
else:
path = pathlist[0]
return path
if (appname and version):
path = os.path.join(path, version)
return path
| [
"def",
"site_data_dir",
"(",
"appname",
"=",
"None",
",",
"appauthor",
"=",
"None",
",",
"version",
"=",
"None",
",",
"multipath",
"=",
"False",
")",
":",
"if",
"(",
"sys",
".",
"platform",
"==",
"'win32'",
")",
":",
"if",
"(",
"appauthor",
"is",
"No... | return full path to the user-shared data dir for this application . | train | true |
6,586 | def request_soup(url, **kwargs):
parser = kwargs.pop('parser', 'html5lib')
response = request_response(url, **kwargs)
if (response is not None):
return BeautifulSoup(response.content, parser)
| [
"def",
"request_soup",
"(",
"url",
",",
"**",
"kwargs",
")",
":",
"parser",
"=",
"kwargs",
".",
"pop",
"(",
"'parser'",
",",
"'html5lib'",
")",
"response",
"=",
"request_response",
"(",
"url",
",",
"**",
"kwargs",
")",
"if",
"(",
"response",
"is",
"not... | wrapper for request_response . | train | false |
6,587 | def is_percentage_failure(error_message):
if ('Subprocess return code: 1' not in error_message):
return False
else:
return True
| [
"def",
"is_percentage_failure",
"(",
"error_message",
")",
":",
"if",
"(",
"'Subprocess return code: 1'",
"not",
"in",
"error_message",
")",
":",
"return",
"False",
"else",
":",
"return",
"True"
] | when diff-quality is run with a threshold percentage . | train | false |
6,588 | def readAuthorizedKeyFile(fileobj, parseKey=keys.Key.fromString):
for line in fileobj:
line = line.strip()
if (line and (not line.startswith('#'))):
try:
(yield parseKey(line))
except keys.BadKeyError as e:
log.msg('Unable to parse line "{0}" as a key: {1!s}'.format(line, e))
| [
"def",
"readAuthorizedKeyFile",
"(",
"fileobj",
",",
"parseKey",
"=",
"keys",
".",
"Key",
".",
"fromString",
")",
":",
"for",
"line",
"in",
"fileobj",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"(",
"line",
"and",
"(",
"not",
"line",
"."... | reads keys from an authorized keys file . | train | false |
6,589 | def module_list(path):
if (path == ''):
path = '.'
pjoin = os.path.join
if os.path.isdir(path):
files = []
for (root, dirs, nondirs) in os.walk(path):
subdir = root[(len(path) + 1):]
if subdir:
files.extend((pjoin(subdir, f) for f in nondirs))
dirs[:] = []
else:
files.extend(nondirs)
else:
try:
files = list(zipimporter(path)._files.keys())
except:
files = []
modules = []
for f in files:
m = import_re.match(f)
if m:
modules.append(m.group('name'))
return list(set(modules))
| [
"def",
"module_list",
"(",
"path",
")",
":",
"if",
"(",
"path",
"==",
"''",
")",
":",
"path",
"=",
"'.'",
"pjoin",
"=",
"os",
".",
"path",
".",
"join",
"if",
"os",
".",
"path",
".",
"isdir",
"(",
"path",
")",
":",
"files",
"=",
"[",
"]",
"for... | return the list containing the names of the modules available in the given folder . | train | false |
6,590 | def flatten_blocks(lines, num_indents=(-1)):
INDENTATION = (' ' * 4)
if (not lines):
return ''
if isinstance(lines, six.string_types):
return ((INDENTATION * num_indents) + lines)
return '\n'.join([flatten_blocks(line, (num_indents + 1)) for line in lines])
| [
"def",
"flatten_blocks",
"(",
"lines",
",",
"num_indents",
"=",
"(",
"-",
"1",
")",
")",
":",
"INDENTATION",
"=",
"(",
"' '",
"*",
"4",
")",
"if",
"(",
"not",
"lines",
")",
":",
"return",
"''",
"if",
"isinstance",
"(",
"lines",
",",
"six",
".",
"... | takes a list or string and flattens it into a string with indentation . | train | true |
6,591 | def hist_calls(fn):
@functools.wraps(fn)
def wrapper(*args, **kwargs):
_histogram = histogram(('%s_calls' % get_qualname(fn)))
rtn = fn(*args, **kwargs)
if (type(rtn) in (int, float)):
_histogram.update(rtn)
return rtn
return wrapper
| [
"def",
"hist_calls",
"(",
"fn",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"fn",
")",
"def",
"wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"_histogram",
"=",
"histogram",
"(",
"(",
"'%s_calls'",
"%",
"get_qualname",
"(",
"fn",
")",
... | decorator to check the distribution of return values of a function . | train | false |
6,592 | def indexes(db=None):
return indices(db)
| [
"def",
"indexes",
"(",
"db",
"=",
"None",
")",
":",
"return",
"indices",
"(",
"db",
")"
] | show all indices in the database . | train | false |
6,593 | def register_home(route):
global _home
_home = route
| [
"def",
"register_home",
"(",
"route",
")",
":",
"global",
"_home",
"_home",
"=",
"route"
] | registers ui home page . | train | false |
6,596 | @handle_response_format
@treeio_login_required
@module_admin_required()
def page_add(request, response_format='html'):
if request.POST:
form = PageForm(request.POST)
if form.is_valid():
page = form.save()
return HttpResponseRedirect(reverse('core_admin_page_view', args=[page.id]))
else:
form = PageForm()
return render_to_response('core/administration/page_add', {'form': form}, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"handle_response_format",
"@",
"treeio_login_required",
"@",
"module_admin_required",
"(",
")",
"def",
"page_add",
"(",
"request",
",",
"response_format",
"=",
"'html'",
")",
":",
"if",
"request",
".",
"POST",
":",
"form",
"=",
"PageForm",
"(",
"request",
... | static page add . | train | false |
6,597 | def get_indexer_numbering_for_xem(indexer_id, indexer, sceneSeason, sceneEpisode):
if ((indexer_id is None) or (sceneSeason is None) or (sceneEpisode is None)):
return (sceneSeason, sceneEpisode)
indexer_id = int(indexer_id)
indexer = int(indexer)
xem_refresh(indexer_id, indexer)
dbData = [x[u'doc'] for x in sickrage.srCore.mainDB.db.get_many(u'tv_episodes', indexer_id, with_doc=True) if ((x[u'doc'][u'indexer'] == indexer) and (x[u'doc'][u'scene_season'] == sceneSeason) and (x[u'doc'][u'scene_episode'] == sceneEpisode))]
if dbData:
return (int((dbData[0][u'season'] or 0)), int((dbData[0][u'episode'] or 0)))
return (sceneSeason, sceneEpisode)
| [
"def",
"get_indexer_numbering_for_xem",
"(",
"indexer_id",
",",
"indexer",
",",
"sceneSeason",
",",
"sceneEpisode",
")",
":",
"if",
"(",
"(",
"indexer_id",
"is",
"None",
")",
"or",
"(",
"sceneSeason",
"is",
"None",
")",
"or",
"(",
"sceneEpisode",
"is",
"None... | reverse of find_xem_numbering: lookup a tvdb season and episode using scene numbering . | train | false |
6,598 | def _get_wiki_link(title, locale):
from kitsune.wiki.models import Document
d = get_object_fallback(Document, locale=locale, title=title, is_template=False)
if d:
while d.redirect_document():
d = d.redirect_document()
url = reverse('wiki.document', locale=locale, args=[d.slug])
return {'found': True, 'url': url, 'text': d.title}
from kitsune.sumo.templatetags.jinja_helpers import urlparams
return {'found': False, 'text': title, 'url': urlparams(reverse('wiki.new_document', locale=locale), title=title)}
| [
"def",
"_get_wiki_link",
"(",
"title",
",",
"locale",
")",
":",
"from",
"kitsune",
".",
"wiki",
".",
"models",
"import",
"Document",
"d",
"=",
"get_object_fallback",
"(",
"Document",
",",
"locale",
"=",
"locale",
",",
"title",
"=",
"title",
",",
"is_templa... | checks the page exists . | train | false |
6,599 | def _isolate_zero(f, K, inf, sup, basis=False, sqf=False):
(j, f) = dup_terms_gcd(f, K)
if (j > 0):
F = K.get_field()
if (((inf is None) or (inf <= 0)) and ((sup is None) or (0 <= sup))):
if (not sqf):
if (not basis):
return ([((F.zero, F.zero), j)], f)
else:
return ([((F.zero, F.zero), j, [K.one, K.zero])], f)
else:
return ([(F.zero, F.zero)], f)
return ([], f)
| [
"def",
"_isolate_zero",
"(",
"f",
",",
"K",
",",
"inf",
",",
"sup",
",",
"basis",
"=",
"False",
",",
"sqf",
"=",
"False",
")",
":",
"(",
"j",
",",
"f",
")",
"=",
"dup_terms_gcd",
"(",
"f",
",",
"K",
")",
"if",
"(",
"j",
">",
"0",
")",
":",
... | handle special case of cf algorithm when f is homogeneous . | train | false |
6,600 | def make_label_dec(label, ds=None):
warnings.warn('The function `make_label_dec` is deprecated since IPython 4.0', DeprecationWarning, stacklevel=2)
if isinstance(label, str):
labels = [label]
else:
labels = label
tmp = (lambda : None)
for label in labels:
setattr(tmp, label, True)
def decor(f):
for label in labels:
setattr(f, label, True)
return f
if (ds is None):
ds = ('Labels a test as %r.' % label)
decor.__doc__ = ds
return decor
| [
"def",
"make_label_dec",
"(",
"label",
",",
"ds",
"=",
"None",
")",
":",
"warnings",
".",
"warn",
"(",
"'The function `make_label_dec` is deprecated since IPython 4.0'",
",",
"DeprecationWarning",
",",
"stacklevel",
"=",
"2",
")",
"if",
"isinstance",
"(",
"label",
... | factory function to create a decorator that applies one or more labels . | train | false |
6,601 | def make_theano_rng(rng_or_seed=None, default_seed=None, which_method=None):
return make_rng(rng_or_seed, default_seed, which_method, RandomStreams)
| [
"def",
"make_theano_rng",
"(",
"rng_or_seed",
"=",
"None",
",",
"default_seed",
"=",
"None",
",",
"which_method",
"=",
"None",
")",
":",
"return",
"make_rng",
"(",
"rng_or_seed",
",",
"default_seed",
",",
"which_method",
",",
"RandomStreams",
")"
] | returns a theano randomstreams . | train | false |
6,602 | def comb_w_rep(n, k):
if (k == 0):
return [[]]
combs = [[i] for i in range(n)]
for i in range((k - 1)):
curr = []
for p in combs:
for m in range(p[(-1)], n):
curr.append((p + [m]))
combs = curr
return combs
| [
"def",
"comb_w_rep",
"(",
"n",
",",
"k",
")",
":",
"if",
"(",
"k",
"==",
"0",
")",
":",
"return",
"[",
"[",
"]",
"]",
"combs",
"=",
"[",
"[",
"i",
"]",
"for",
"i",
"in",
"range",
"(",
"n",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"(",
... | combinations with repetition returns the list of k combinations with repetition from n objects . | train | false |
6,604 | def has_mixed_eol_chars(text):
eol_chars = get_eol_chars(text)
if (eol_chars is None):
return False
correct_text = eol_chars.join((text + eol_chars).splitlines())
return (repr(correct_text) != repr(text))
| [
"def",
"has_mixed_eol_chars",
"(",
"text",
")",
":",
"eol_chars",
"=",
"get_eol_chars",
"(",
"text",
")",
"if",
"(",
"eol_chars",
"is",
"None",
")",
":",
"return",
"False",
"correct_text",
"=",
"eol_chars",
".",
"join",
"(",
"(",
"text",
"+",
"eol_chars",
... | detect if text has mixed eol characters . | train | true |
6,605 | def middleware(application, global_conf=None):
def lint_app(*args, **kw):
assert (len(args) == 2), u'Two arguments required'
assert (not kw), u'No keyword arguments allowed'
(environ, start_response) = args
check_environ(environ)
start_response_started = []
def start_response_wrapper(*args, **kw):
assert ((len(args) == 2) or (len(args) == 3)), (u'Invalid number of arguments: %s' % args)
assert (not kw), u'No keyword arguments allowed'
status = args[0]
headers = args[1]
if (len(args) == 3):
exc_info = args[2]
else:
exc_info = None
check_status(status)
check_headers(headers)
check_content_type(status, headers)
check_exc_info(exc_info)
start_response_started.append(None)
return WriteWrapper(start_response(*args))
environ[u'wsgi.input'] = InputWrapper(environ[u'wsgi.input'])
environ[u'wsgi.errors'] = ErrorWrapper(environ[u'wsgi.errors'])
iterator = application(environ, start_response_wrapper)
assert isinstance(iterator, collections.Iterable), u'The application must return an iterator, if only an empty list'
check_iterator(iterator)
return IteratorWrapper(iterator, start_response_started)
return lint_app
| [
"def",
"middleware",
"(",
"application",
",",
"global_conf",
"=",
"None",
")",
":",
"def",
"lint_app",
"(",
"*",
"args",
",",
"**",
"kw",
")",
":",
"assert",
"(",
"len",
"(",
"args",
")",
"==",
"2",
")",
",",
"u'Two arguments required'",
"assert",
"(",... | when applied between a wsgi server and a wsgi application . | train | false |
6,606 | def f_3():
__doc__ = 'new f 3 doc'
return __doc__
| [
"def",
"f_3",
"(",
")",
":",
"__doc__",
"=",
"'new f 3 doc'",
"return",
"__doc__"
] | f 3 doc . | train | false |
6,607 | def build_pattern(log_format):
if (log_format == 'combined'):
log_format = LOG_FORMAT_COMBINED
elif (log_format == 'common'):
log_format = LOG_FORMAT_COMMON
pattern = re.sub(REGEX_SPECIAL_CHARS, '\\\\\\1', log_format)
pattern = re.sub(REGEX_LOG_FORMAT_VARIABLE, '(?P<\\1>.*)', pattern)
return re.compile(pattern)
| [
"def",
"build_pattern",
"(",
"log_format",
")",
":",
"if",
"(",
"log_format",
"==",
"'combined'",
")",
":",
"log_format",
"=",
"LOG_FORMAT_COMBINED",
"elif",
"(",
"log_format",
"==",
"'common'",
")",
":",
"log_format",
"=",
"LOG_FORMAT_COMMON",
"pattern",
"=",
... | build regular expression to parse given format . | train | true |
6,608 | def cocktail_shaker_sort(unsorted):
for i in range((len(unsorted) - 1), 0, (-1)):
swapped = False
for j in range(i, 0, (-1)):
if (unsorted[j] < unsorted[(j - 1)]):
(unsorted[j], unsorted[(j - 1)]) = (unsorted[(j - 1)], unsorted[j])
swapped = True
for j in range(i):
if (unsorted[j] > unsorted[(j + 1)]):
(unsorted[j], unsorted[(j + 1)]) = (unsorted[(j + 1)], unsorted[j])
swapped = True
if (not swapped):
return unsorted
| [
"def",
"cocktail_shaker_sort",
"(",
"unsorted",
")",
":",
"for",
"i",
"in",
"range",
"(",
"(",
"len",
"(",
"unsorted",
")",
"-",
"1",
")",
",",
"0",
",",
"(",
"-",
"1",
")",
")",
":",
"swapped",
"=",
"False",
"for",
"j",
"in",
"range",
"(",
"i"... | pure implementation of the cocktail shaker sort algorithm in python . | train | false |
6,609 | def template_assets_path(instance, filename):
name = os.path.join('certificate_template_assets', str(instance.id), filename)
fullname = os.path.join(settings.MEDIA_ROOT, name)
if os.path.exists(fullname):
os.remove(fullname)
return name
| [
"def",
"template_assets_path",
"(",
"instance",
",",
"filename",
")",
":",
"name",
"=",
"os",
".",
"path",
".",
"join",
"(",
"'certificate_template_assets'",
",",
"str",
"(",
"instance",
".",
"id",
")",
",",
"filename",
")",
"fullname",
"=",
"os",
".",
"... | delete the file if it already exist and returns the certificate template asset file path . | train | false |
6,611 | def process_stdin(line):
if (line is None):
sys.exit(0)
if (mpstate.functions.input_handler is not None):
mpstate.functions.input_handler(line)
return
line = line.strip()
if mpstate.status.setup_mode:
if (line == '.'):
mpstate.status.setup_mode = False
mpstate.status.flightmode = 'MAV'
mpstate.rl.set_prompt('MAV> ')
return
if (line != '+++'):
line += '\r'
for c in line:
time.sleep(0.01)
mpstate.master().write(c)
return
if (not line):
return
args = shlex_quotes(line)
cmd = args[0]
while (cmd in mpstate.aliases):
line = mpstate.aliases[cmd]
args = (shlex.split(line) + args[1:])
cmd = args[0]
if (cmd == 'help'):
k = command_map.keys()
k.sort()
for cmd in k:
(fn, help) = command_map[cmd]
print ('%-15s : %s' % (cmd, help))
return
if ((cmd == 'exit') and mpstate.settings.requireexit):
mpstate.status.exit = True
return
if (not (cmd in command_map)):
for (m, pm) in mpstate.modules:
if hasattr(m, 'unknown_command'):
try:
if m.unknown_command(args):
return
except Exception as e:
print ('ERROR in command: %s' % str(e))
print ("Unknown command '%s'" % line)
return
(fn, help) = command_map[cmd]
try:
fn(args[1:])
except Exception as e:
print ('ERROR in command %s: %s' % (args[1:], str(e)))
if (mpstate.settings.moddebug > 1):
traceback.print_exc()
| [
"def",
"process_stdin",
"(",
"line",
")",
":",
"if",
"(",
"line",
"is",
"None",
")",
":",
"sys",
".",
"exit",
"(",
"0",
")",
"if",
"(",
"mpstate",
".",
"functions",
".",
"input_handler",
"is",
"not",
"None",
")",
":",
"mpstate",
".",
"functions",
"... | handle commands from user . | train | true |
6,612 | def clustermap(data, pivot_kws=None, method='average', metric='euclidean', z_score=None, standard_scale=None, figsize=None, cbar_kws=None, row_cluster=True, col_cluster=True, row_linkage=None, col_linkage=None, row_colors=None, col_colors=None, mask=None, **kwargs):
plotter = ClusterGrid(data, pivot_kws=pivot_kws, figsize=figsize, row_colors=row_colors, col_colors=col_colors, z_score=z_score, standard_scale=standard_scale, mask=mask)
return plotter.plot(metric=metric, method=method, colorbar_kws=cbar_kws, row_cluster=row_cluster, col_cluster=col_cluster, row_linkage=row_linkage, col_linkage=col_linkage, **kwargs)
| [
"def",
"clustermap",
"(",
"data",
",",
"pivot_kws",
"=",
"None",
",",
"method",
"=",
"'average'",
",",
"metric",
"=",
"'euclidean'",
",",
"z_score",
"=",
"None",
",",
"standard_scale",
"=",
"None",
",",
"figsize",
"=",
"None",
",",
"cbar_kws",
"=",
"None... | plot a hierarchically clustered heatmap of a pandas dataframe parameters data: pandas . | train | false |
6,613 | def get_machine_id_change_spec(client_factory, machine_id_str):
virtual_machine_config_spec = client_factory.create('ns0:VirtualMachineConfigSpec')
opt = client_factory.create('ns0:OptionValue')
opt.key = 'machine.id'
opt.value = machine_id_str
virtual_machine_config_spec.extraConfig = [opt]
return virtual_machine_config_spec
| [
"def",
"get_machine_id_change_spec",
"(",
"client_factory",
",",
"machine_id_str",
")",
":",
"virtual_machine_config_spec",
"=",
"client_factory",
".",
"create",
"(",
"'ns0:VirtualMachineConfigSpec'",
")",
"opt",
"=",
"client_factory",
".",
"create",
"(",
"'ns0:OptionValu... | builds the machine id change config spec . | train | false |
6,614 | def retry_argument_spec(spec=None):
arg_spec = dict(retries=dict(type='int'), retry_pause=dict(type='float', default=1))
if spec:
arg_spec.update(spec)
return arg_spec
| [
"def",
"retry_argument_spec",
"(",
"spec",
"=",
"None",
")",
":",
"arg_spec",
"=",
"dict",
"(",
"retries",
"=",
"dict",
"(",
"type",
"=",
"'int'",
")",
",",
"retry_pause",
"=",
"dict",
"(",
"type",
"=",
"'float'",
",",
"default",
"=",
"1",
")",
")",
... | creates an argument spec for working with retrying . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.