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 |
|---|---|---|---|---|---|
10,029 | def _read_epoch(fid):
out = {'pts_in_epoch': read_int32(fid), 'epoch_duration': read_float(fid), 'expected_iti': read_float(fid), 'actual_iti': read_float(fid), 'total_var_events': read_int32(fid), 'checksum': read_int32(fid), 'epoch_timestamp': read_int32(fid)}
fid.seek(28, 1)
return out
| [
"def",
"_read_epoch",
"(",
"fid",
")",
":",
"out",
"=",
"{",
"'pts_in_epoch'",
":",
"read_int32",
"(",
"fid",
")",
",",
"'epoch_duration'",
":",
"read_float",
"(",
"fid",
")",
",",
"'expected_iti'",
":",
"read_float",
"(",
"fid",
")",
",",
"'actual_iti'",
... | read bti pdf epoch . | train | false |
10,030 | def multi_theme_percentage_represent(id):
if (not id):
return current.messages['NONE']
s3db = current.s3db
table = s3db.project_theme_percentage
ttable = s3db.project_theme
def represent_row(row):
return ('%s (%s%s)' % (row.project_theme.name, row.project_theme_percentage.percentage, '%'))
if isinstance(id, (list, tuple)):
query = (table.id.belongs(id) & (ttable.id == table.theme_id))
rows = current.db(query).select(table.percentage, ttable.name)
repr = ', '.join((represent_row(row) for row in rows))
return repr
else:
query = ((table.id == id) & (ttable.id == table.theme_id))
row = current.db(query).select(table.percentage, ttable.name).first()
try:
return represent_row(row)
except:
return current.messages.UNKNOWN_OPT
| [
"def",
"multi_theme_percentage_represent",
"(",
"id",
")",
":",
"if",
"(",
"not",
"id",
")",
":",
"return",
"current",
".",
"messages",
"[",
"'NONE'",
"]",
"s3db",
"=",
"current",
".",
"s3db",
"table",
"=",
"s3db",
".",
"project_theme_percentage",
"ttable",
... | representation for theme percentages for multiple=true options . | train | false |
10,031 | def _filter_bultins(module):
name = module.__name__
return ((not name.startswith('django.contrib')) and (name != 'lettuce.django'))
| [
"def",
"_filter_bultins",
"(",
"module",
")",
":",
"name",
"=",
"module",
".",
"__name__",
"return",
"(",
"(",
"not",
"name",
".",
"startswith",
"(",
"'django.contrib'",
")",
")",
"and",
"(",
"name",
"!=",
"'lettuce.django'",
")",
")"
] | returns only those apps that are not builtin django . | train | false |
10,032 | def _raise_error_network(option, expected):
msg = _error_msg_network(option, expected)
log.error(msg)
raise AttributeError(msg)
| [
"def",
"_raise_error_network",
"(",
"option",
",",
"expected",
")",
":",
"msg",
"=",
"_error_msg_network",
"(",
"option",
",",
"expected",
")",
"log",
".",
"error",
"(",
"msg",
")",
"raise",
"AttributeError",
"(",
"msg",
")"
] | log and raise an error with a logical formatted message . | train | true |
10,034 | def unproject(winx, winy, winz, modelMatrix, projMatrix, viewport):
npModelMatrix = numpy.matrix(numpy.array(modelMatrix, numpy.float64).reshape((4, 4)))
npProjMatrix = numpy.matrix(numpy.array(projMatrix, numpy.float64).reshape((4, 4)))
finalMatrix = (npModelMatrix * npProjMatrix)
finalMatrix = numpy.linalg.inv(finalMatrix)
viewport = map(float, viewport)
vector = numpy.array([((((winx - viewport[0]) / viewport[2]) * 2.0) - 1.0), ((((winy - viewport[1]) / viewport[3]) * 2.0) - 1.0), ((winz * 2.0) - 1.0), 1]).reshape((1, 4))
vector = (numpy.matrix(vector) * finalMatrix).getA().flatten()
ret = (list(vector)[0:3] / vector[3])
return ret
| [
"def",
"unproject",
"(",
"winx",
",",
"winy",
",",
"winz",
",",
"modelMatrix",
",",
"projMatrix",
",",
"viewport",
")",
":",
"npModelMatrix",
"=",
"numpy",
".",
"matrix",
"(",
"numpy",
".",
"array",
"(",
"modelMatrix",
",",
"numpy",
".",
"float64",
")",
... | projects window position to 3d space . | train | false |
10,035 | def saveNameCacheToDb():
cache_db_con = db.DBConnection('cache.db')
for (name, indexer_id) in nameCache.iteritems():
cache_db_con.action('INSERT OR REPLACE INTO scene_names (indexer_id, name) VALUES (?, ?)', [indexer_id, name])
| [
"def",
"saveNameCacheToDb",
"(",
")",
":",
"cache_db_con",
"=",
"db",
".",
"DBConnection",
"(",
"'cache.db'",
")",
"for",
"(",
"name",
",",
"indexer_id",
")",
"in",
"nameCache",
".",
"iteritems",
"(",
")",
":",
"cache_db_con",
".",
"action",
"(",
"'INSERT ... | commit cache to database file . | train | false |
10,036 | def render_link_tag(url, rel=u'stylesheet', media=None):
attrs = {u'href': url, u'rel': rel}
if media:
attrs[u'media'] = media
return render_tag(u'link', attrs=attrs, close=False)
| [
"def",
"render_link_tag",
"(",
"url",
",",
"rel",
"=",
"u'stylesheet'",
",",
"media",
"=",
"None",
")",
":",
"attrs",
"=",
"{",
"u'href'",
":",
"url",
",",
"u'rel'",
":",
"rel",
"}",
"if",
"media",
":",
"attrs",
"[",
"u'media'",
"]",
"=",
"media",
... | build a link tag . | train | false |
10,037 | def group(seq, size):
if (not hasattr(seq, 'next')):
seq = iter(seq)
while True:
(yield [seq.next() for i in xrange(size)])
| [
"def",
"group",
"(",
"seq",
",",
"size",
")",
":",
"if",
"(",
"not",
"hasattr",
"(",
"seq",
",",
"'next'",
")",
")",
":",
"seq",
"=",
"iter",
"(",
"seq",
")",
"while",
"True",
":",
"(",
"yield",
"[",
"seq",
".",
"next",
"(",
")",
"for",
"i",
... | module-specific controller for teams @note: currently for development/testing/demo purposes only . | train | false |
10,038 | def dmp_to_dict(f, u, K=None, zero=False):
if (not u):
return dup_to_dict(f, K, zero=zero)
if (dmp_zero_p(f, u) and zero):
return {((0,) * (u + 1)): K.zero}
(n, v, result) = (dmp_degree(f, u), (u - 1), {})
if (n == (- oo)):
n = (-1)
for k in range(0, (n + 1)):
h = dmp_to_dict(f[(n - k)], v)
for (exp, coeff) in h.items():
result[((k,) + exp)] = coeff
return result
| [
"def",
"dmp_to_dict",
"(",
"f",
",",
"u",
",",
"K",
"=",
"None",
",",
"zero",
"=",
"False",
")",
":",
"if",
"(",
"not",
"u",
")",
":",
"return",
"dup_to_dict",
"(",
"f",
",",
"K",
",",
"zero",
"=",
"zero",
")",
"if",
"(",
"dmp_zero_p",
"(",
"... | convert a k[x] polynomial to a dict . | train | false |
10,040 | def run_traffic_step(emr_connection, step, jobflow_name, wait=True, sleeptime=60, retries=1, **jobflow_kw):
jobflowid = _add_step(emr_connection, step, jobflow_name, **jobflow_kw)
if (not wait):
return
attempts = 1
exit_state = _wait_for_step(emr_connection, step, jobflowid, sleeptime)
while ((attempts <= retries) and (exit_state != COMPLETED)):
jobflowid = _add_step(emr_connection, step, jobflow_name, **jobflow_kw)
exit_state = _wait_for_step(emr_connection, step, jobflowid, sleeptime)
attempts += 1
if (exit_state != COMPLETED):
msg = ('%s failed (exit: %s)' % (step.name, exit_state))
if retries:
msg += ('retried %s times' % retries)
raise EmrException(msg)
| [
"def",
"run_traffic_step",
"(",
"emr_connection",
",",
"step",
",",
"jobflow_name",
",",
"wait",
"=",
"True",
",",
"sleeptime",
"=",
"60",
",",
"retries",
"=",
"1",
",",
"**",
"jobflow_kw",
")",
":",
"jobflowid",
"=",
"_add_step",
"(",
"emr_connection",
",... | run a traffic processing step . | train | false |
10,041 | def get_machine_ips():
addresses = []
for interface in netifaces.interfaces():
try:
iface_data = netifaces.ifaddresses(interface)
for family in iface_data:
if (family not in (netifaces.AF_INET, netifaces.AF_INET6)):
continue
for address in iface_data[family]:
addr = address['addr']
if (family == netifaces.AF_INET6):
addr = addr.split('%')[0]
addresses.append(addr)
except ValueError:
pass
return addresses
| [
"def",
"get_machine_ips",
"(",
")",
":",
"addresses",
"=",
"[",
"]",
"for",
"interface",
"in",
"netifaces",
".",
"interfaces",
"(",
")",
":",
"try",
":",
"iface_data",
"=",
"netifaces",
".",
"ifaddresses",
"(",
"interface",
")",
"for",
"family",
"in",
"i... | get the machines ip addresses :returns: list of strings of ip addresses . | train | false |
10,044 | def mirror(image):
return image.transpose(Image.FLIP_LEFT_RIGHT)
| [
"def",
"mirror",
"(",
"image",
")",
":",
"return",
"image",
".",
"transpose",
"(",
"Image",
".",
"FLIP_LEFT_RIGHT",
")"
] | rotate a comparison operator 180 degrees . | train | false |
10,045 | def returns_None(function):
def call_and_assert(*args, **kwargs):
original_args = copy.deepcopy(args)
original_kwargs = copy.deepcopy(kwargs)
result = function(*args, **kwargs)
assert (result is None), 'Should return None when called with args: {args} and kwargs: {kwargs}'.format(args=original_args, kwargs=original_kwargs)
return result
return call_and_assert
| [
"def",
"returns_None",
"(",
"function",
")",
":",
"def",
"call_and_assert",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"original_args",
"=",
"copy",
".",
"deepcopy",
"(",
"args",
")",
"original_kwargs",
"=",
"copy",
".",
"deepcopy",
"(",
"kwargs",
... | a decorator that asserts that the decorated function returns none . | train | false |
10,047 | def install_hook():
for hook in sys.meta_path:
if isinstance(hook, XonshImportHook):
break
else:
sys.meta_path.append(XonshImportHook())
| [
"def",
"install_hook",
"(",
")",
":",
"for",
"hook",
"in",
"sys",
".",
"meta_path",
":",
"if",
"isinstance",
"(",
"hook",
",",
"XonshImportHook",
")",
":",
"break",
"else",
":",
"sys",
".",
"meta_path",
".",
"append",
"(",
"XonshImportHook",
"(",
")",
... | install xonsh import hook in sys . | train | false |
10,048 | def test_reflected_event_ops():
AreEqual(str(IronPythonTest.Events.StaticTest.Event), '<event# StaticTest on Events>')
t_list = [IronPythonTest.Events.StaticTest.Event, IronPythonTest.Events().InstanceTest.Event]
for stuff in t_list:
for (inst, val) in [(None, None), (1, None), (None, 1), (1, 1), ('abc', 'xyz')]:
AssertError(AttributeError, stuff.__set__, inst, val)
AssertError(AttributeError, stuff.__delete__, inst)
AssertError(AttributeError, IronPythonTest.Events.StaticTest.Event.__set__, None, IronPythonTest.Events().InstanceTest)
AssertError(AttributeError, IronPythonTest.Events.StaticTest.Event.__delete__, IronPythonTest.Events().InstanceTest)
for stuff in [None, 1, 'abc']:
IronPythonTest.Events.StaticTest.Event.__set__(stuff, IronPythonTest.Events.StaticTest)
| [
"def",
"test_reflected_event_ops",
"(",
")",
":",
"AreEqual",
"(",
"str",
"(",
"IronPythonTest",
".",
"Events",
".",
"StaticTest",
".",
"Event",
")",
",",
"'<event# StaticTest on Events>'",
")",
"t_list",
"=",
"[",
"IronPythonTest",
".",
"Events",
".",
"StaticTe... | test to hit ironpython . | train | false |
10,049 | @register.filter
def thumbnailer(obj, relative_name=None):
return get_thumbnailer(obj, relative_name=relative_name)
| [
"@",
"register",
".",
"filter",
"def",
"thumbnailer",
"(",
"obj",
",",
"relative_name",
"=",
"None",
")",
":",
"return",
"get_thumbnailer",
"(",
"obj",
",",
"relative_name",
"=",
"relative_name",
")"
] | creates a thumbnailer from an object . | train | false |
10,051 | def IIDToInterfaceName(iid):
try:
return pythoncom.ServerInterfaces[iid]
except KeyError:
try:
try:
return win32api.RegQueryValue(win32con.HKEY_CLASSES_ROOT, ('Interface\\%s' % iid))
except win32api.error:
pass
except ImportError:
pass
return str(iid)
| [
"def",
"IIDToInterfaceName",
"(",
"iid",
")",
":",
"try",
":",
"return",
"pythoncom",
".",
"ServerInterfaces",
"[",
"iid",
"]",
"except",
"KeyError",
":",
"try",
":",
"try",
":",
"return",
"win32api",
".",
"RegQueryValue",
"(",
"win32con",
".",
"HKEY_CLASSES... | converts an iid to a string interface name . | train | false |
10,053 | def unlock(hass, entity_id=None, code=None):
data = {}
if code:
data[ATTR_CODE] = code
if entity_id:
data[ATTR_ENTITY_ID] = entity_id
hass.services.call(DOMAIN, SERVICE_UNLOCK, data)
| [
"def",
"unlock",
"(",
"hass",
",",
"entity_id",
"=",
"None",
",",
"code",
"=",
"None",
")",
":",
"data",
"=",
"{",
"}",
"if",
"code",
":",
"data",
"[",
"ATTR_CODE",
"]",
"=",
"code",
"if",
"entity_id",
":",
"data",
"[",
"ATTR_ENTITY_ID",
"]",
"=",
... | remove lease from semaphore . | train | false |
10,054 | def cr(method):
method._api = 'cr'
return method
| [
"def",
"cr",
"(",
"method",
")",
":",
"method",
".",
"_api",
"=",
"'cr'",
"return",
"method"
] | decorate a traditional-style method that takes cr as a parameter . | train | false |
10,057 | def nexus_artifact_uploader(registry, xml_parent, data):
nexus_artifact_uploader = XML.SubElement(xml_parent, 'sp.sd.nexusartifactuploader.NexusArtifactUploader')
mapping = [('protocol', 'protocol', 'https'), ('nexus_url', 'nexusUrl', ''), ('nexus_user', 'nexusUser', ''), ('nexus_password', 'nexusPassword', ''), ('group_id', 'groupId', ''), ('artifact_id', 'artifactId', ''), ('version', 'version', ''), ('packaging', 'packaging', ''), ('type', 'type', ''), ('classifier', 'classifier', ''), ('repository', 'repository', ''), ('file', 'file', ''), ('credentials_id', 'credentialsId', '')]
convert_mapping_to_xml(nexus_artifact_uploader, data, mapping, fail_required=True)
| [
"def",
"nexus_artifact_uploader",
"(",
"registry",
",",
"xml_parent",
",",
"data",
")",
":",
"nexus_artifact_uploader",
"=",
"XML",
".",
"SubElement",
"(",
"xml_parent",
",",
"'sp.sd.nexusartifactuploader.NexusArtifactUploader'",
")",
"mapping",
"=",
"[",
"(",
"'proto... | yaml: nexus-artifact-uploader to upload result of a build as an artifact in nexus without the need of maven . | train | false |
10,058 | def show_vpnservice(vpnservice, profile=None, **kwargs):
conn = _auth(profile)
return conn.show_vpnservice(vpnservice, **kwargs)
| [
"def",
"show_vpnservice",
"(",
"vpnservice",
",",
"profile",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"conn",
"=",
"_auth",
"(",
"profile",
")",
"return",
"conn",
".",
"show_vpnservice",
"(",
"vpnservice",
",",
"**",
"kwargs",
")"
] | fetches information of a specific vpn service cli example: . | train | true |
10,059 | def sparse(v):
for (f, w) in list(v.items()):
if (w == 0):
del v[f]
return v
| [
"def",
"sparse",
"(",
"v",
")",
":",
"for",
"(",
"f",
",",
"w",
")",
"in",
"list",
"(",
"v",
".",
"items",
"(",
")",
")",
":",
"if",
"(",
"w",
"==",
"0",
")",
":",
"del",
"v",
"[",
"f",
"]",
"return",
"v"
] | returns the vector with features that have weight 0 removed . | train | false |
10,060 | def binary_repr(number, max_length=1025):
shifts = list(map(operator.rshift, (max_length * [number]), range((max_length - 1), (-1), (-1))))
digits = list(map(operator.mod, shifts, (max_length * [2])))
if (not digits.count(1)):
return 0
digits = digits[digits.index(1):]
return u''.join(map(repr, digits)).replace(u'L', u'')
| [
"def",
"binary_repr",
"(",
"number",
",",
"max_length",
"=",
"1025",
")",
":",
"shifts",
"=",
"list",
"(",
"map",
"(",
"operator",
".",
"rshift",
",",
"(",
"max_length",
"*",
"[",
"number",
"]",
")",
",",
"range",
"(",
"(",
"max_length",
"-",
"1",
... | return the binary representation of the input *number* as a string . | train | false |
10,061 | def role_get(user):
user_roles = []
with salt.utils.fopen('/etc/user_attr', 'r') as user_attr:
for role in user_attr:
role = role.strip().strip().split(':')
if (len(role) != 5):
continue
if (role[0] != user):
continue
attrs = {}
for attr in role[4].strip().split(';'):
(attr_key, attr_val) = attr.strip().split('=')
if (attr_key in ['auths', 'profiles', 'roles']):
attrs[attr_key] = attr_val.strip().split(',')
else:
attrs[attr_key] = attr_val
if ('roles' in attrs):
user_roles.extend(attrs['roles'])
return list(set(user_roles))
| [
"def",
"role_get",
"(",
"user",
")",
":",
"user_roles",
"=",
"[",
"]",
"with",
"salt",
".",
"utils",
".",
"fopen",
"(",
"'/etc/user_attr'",
",",
"'r'",
")",
"as",
"user_attr",
":",
"for",
"role",
"in",
"user_attr",
":",
"role",
"=",
"role",
".",
"str... | return a dict with information about users of a postgres server . | train | true |
10,062 | def localpath(*args):
plist = ([ROOT] + list(args))
return os.path.abspath(pjoin(*plist))
| [
"def",
"localpath",
"(",
"*",
"args",
")",
":",
"plist",
"=",
"(",
"[",
"ROOT",
"]",
"+",
"list",
"(",
"args",
")",
")",
"return",
"os",
".",
"path",
".",
"abspath",
"(",
"pjoin",
"(",
"*",
"plist",
")",
")"
] | construct an absolute path from a list relative to the root pyzmq directory . | train | true |
10,063 | def valid_max_age(number):
if isinstance(number, basestring):
try:
number = long(number)
except (ValueError, TypeError):
return False
if ((number >= 0) and ((number % 1) == 0)):
return True
return False
| [
"def",
"valid_max_age",
"(",
"number",
")",
":",
"if",
"isinstance",
"(",
"number",
",",
"basestring",
")",
":",
"try",
":",
"number",
"=",
"long",
"(",
"number",
")",
"except",
"(",
"ValueError",
",",
"TypeError",
")",
":",
"return",
"False",
"if",
"(... | validate a cookie max-age . | train | true |
10,064 | def _find_shallow(store, heads, depth):
parents = {}
def get_parents(sha):
result = parents.get(sha, None)
if (not result):
result = store[sha].parents
parents[sha] = result
return result
todo = []
for head_sha in heads:
obj = store.peel_sha(head_sha)
if isinstance(obj, Commit):
todo.append((obj.id, 1))
not_shallow = set()
shallow = set()
while todo:
(sha, cur_depth) = todo.pop()
if (cur_depth < depth):
not_shallow.add(sha)
new_depth = (cur_depth + 1)
todo.extend(((p, new_depth) for p in get_parents(sha)))
else:
shallow.add(sha)
return (shallow, not_shallow)
| [
"def",
"_find_shallow",
"(",
"store",
",",
"heads",
",",
"depth",
")",
":",
"parents",
"=",
"{",
"}",
"def",
"get_parents",
"(",
"sha",
")",
":",
"result",
"=",
"parents",
".",
"get",
"(",
"sha",
",",
"None",
")",
"if",
"(",
"not",
"result",
")",
... | find shallow commits according to a given depth . | train | false |
10,065 | def configure_cache(client, test_name):
client.http_client.cache_test_name = test_name
cache_name = client.http_client.get_cache_file_name()
if (options.get_value('clearcache') == 'true'):
client.http_client.delete_session(cache_name)
client.http_client.use_cached_session(cache_name)
| [
"def",
"configure_cache",
"(",
"client",
",",
"test_name",
")",
":",
"client",
".",
"http_client",
".",
"cache_test_name",
"=",
"test_name",
"cache_name",
"=",
"client",
".",
"http_client",
".",
"get_cache_file_name",
"(",
")",
"if",
"(",
"options",
".",
"get_... | loads or begins a cached session to record http traffic . | train | false |
10,066 | def LSTD_PI_policy(fMap, Ts, R, discountFactor, initpolicy=None, maxIters=20):
def veval(T):
return LSTD_values(T, R, fMap, discountFactor)
return policyIteration(Ts, R, discountFactor, VEvaluator=veval, initpolicy=initpolicy, maxIters=maxIters)
| [
"def",
"LSTD_PI_policy",
"(",
"fMap",
",",
"Ts",
",",
"R",
",",
"discountFactor",
",",
"initpolicy",
"=",
"None",
",",
"maxIters",
"=",
"20",
")",
":",
"def",
"veval",
"(",
"T",
")",
":",
"return",
"LSTD_values",
"(",
"T",
",",
"R",
",",
"fMap",
",... | alternative version of lspi using value functions instead of state-action values as intermediate . | train | false |
10,067 | @receiver(post_save, sender=Check)
def update_failed_check_flag(sender, instance, **kwargs):
if (instance.language is None):
return
related = get_related_units(instance)
if (instance.for_unit is not None):
related = related.exclude(pk=instance.for_unit)
for unit in related:
unit.update_has_failing_check(False)
| [
"@",
"receiver",
"(",
"post_save",
",",
"sender",
"=",
"Check",
")",
"def",
"update_failed_check_flag",
"(",
"sender",
",",
"instance",
",",
"**",
"kwargs",
")",
":",
"if",
"(",
"instance",
".",
"language",
"is",
"None",
")",
":",
"return",
"related",
"=... | update related unit failed check flag . | train | false |
10,068 | def _tolerateErrors(wrapped):
def infoCallback(connection, where, ret):
try:
return wrapped(connection, where, ret)
except:
f = Failure()
log.err(f, 'Error during info_callback')
connection.get_app_data().failVerification(f)
return infoCallback
| [
"def",
"_tolerateErrors",
"(",
"wrapped",
")",
":",
"def",
"infoCallback",
"(",
"connection",
",",
"where",
",",
"ret",
")",
":",
"try",
":",
"return",
"wrapped",
"(",
"connection",
",",
"where",
",",
"ret",
")",
"except",
":",
"f",
"=",
"Failure",
"("... | wrap up an c{info_callback} for pyopenssl so that if something goes wrong the error is immediately logged and the connection is dropped if possible . | train | false |
10,070 | def test_continuous_error():
y = np.linspace(0, 1, 20)
cnn = CondensedNearestNeighbour(random_state=RND_SEED)
assert_warns(UserWarning, cnn.fit, X, y)
| [
"def",
"test_continuous_error",
"(",
")",
":",
"y",
"=",
"np",
".",
"linspace",
"(",
"0",
",",
"1",
",",
"20",
")",
"cnn",
"=",
"CondensedNearestNeighbour",
"(",
"random_state",
"=",
"RND_SEED",
")",
"assert_warns",
"(",
"UserWarning",
",",
"cnn",
".",
"... | test either if an error is raised when the target are continuous type . | train | false |
10,071 | def immnodeset_union(iterable, *args):
set = mutnodeset_union(iterable)
return immnodeset(set, *args)
| [
"def",
"immnodeset_union",
"(",
"iterable",
",",
"*",
"args",
")",
":",
"set",
"=",
"mutnodeset_union",
"(",
"iterable",
")",
"return",
"immnodeset",
"(",
"set",
",",
"*",
"args",
")"
] | return an immmutable nodeset which is the union of all nodesets in iterable . | train | false |
10,072 | def pareto_sequence(n, exponent=1.0):
return [random.paretovariate(exponent) for i in range(n)]
| [
"def",
"pareto_sequence",
"(",
"n",
",",
"exponent",
"=",
"1.0",
")",
":",
"return",
"[",
"random",
".",
"paretovariate",
"(",
"exponent",
")",
"for",
"i",
"in",
"range",
"(",
"n",
")",
"]"
] | return sample sequence of length n from a pareto distribution . | train | false |
10,073 | def TurnIntIntoStrInDict(the_dict):
for (k, v) in the_dict.items():
if (type(v) is int):
v = str(v)
the_dict[k] = v
elif (type(v) is dict):
TurnIntIntoStrInDict(v)
elif (type(v) is list):
TurnIntIntoStrInList(v)
if (type(k) is int):
del the_dict[k]
the_dict[str(k)] = v
| [
"def",
"TurnIntIntoStrInDict",
"(",
"the_dict",
")",
":",
"for",
"(",
"k",
",",
"v",
")",
"in",
"the_dict",
".",
"items",
"(",
")",
":",
"if",
"(",
"type",
"(",
"v",
")",
"is",
"int",
")",
":",
"v",
"=",
"str",
"(",
"v",
")",
"the_dict",
"[",
... | given dict the_dict . | train | false |
10,074 | def fasta_ids(fasta_files, verbose=False):
all_ids = set([])
for fasta_in in fasta_files:
for (label, seq) in parse_fasta(fasta_in):
rid = label.split()[0]
if (rid in all_ids):
raise ValueError(('Duplicate ID found in FASTA/qual file: %s' % label))
all_ids.add(rid)
return all_ids
| [
"def",
"fasta_ids",
"(",
"fasta_files",
",",
"verbose",
"=",
"False",
")",
":",
"all_ids",
"=",
"set",
"(",
"[",
"]",
")",
"for",
"fasta_in",
"in",
"fasta_files",
":",
"for",
"(",
"label",
",",
"seq",
")",
"in",
"parse_fasta",
"(",
"fasta_in",
")",
"... | returns list of ids in fasta files . | train | false |
10,076 | @dec.skip('Testing the skip decorator')
def test_deliberately_broken2():
(1 / 0)
| [
"@",
"dec",
".",
"skip",
"(",
"'Testing the skip decorator'",
")",
"def",
"test_deliberately_broken2",
"(",
")",
":",
"(",
"1",
"/",
"0",
")"
] | another deliberately broken test - we want to skip this one . | train | false |
10,078 | def global_parameters(b, c):
return ((y, ((b[0] - x) - y), x) for (x, y) in zip((b + [0]), ([0] + c)))
| [
"def",
"global_parameters",
"(",
"b",
",",
"c",
")",
":",
"return",
"(",
"(",
"y",
",",
"(",
"(",
"b",
"[",
"0",
"]",
"-",
"x",
")",
"-",
"y",
")",
",",
"x",
")",
"for",
"(",
"x",
",",
"y",
")",
"in",
"zip",
"(",
"(",
"b",
"+",
"[",
"... | return global parameters for a given intersection array . | train | false |
10,079 | def bytes_feature(values):
return tf.train.Feature(bytes_list=tf.train.BytesList(value=[values]))
| [
"def",
"bytes_feature",
"(",
"values",
")",
":",
"return",
"tf",
".",
"train",
".",
"Feature",
"(",
"bytes_list",
"=",
"tf",
".",
"train",
".",
"BytesList",
"(",
"value",
"=",
"[",
"values",
"]",
")",
")"
] | returns a tf-feature of bytes . | train | false |
10,080 | def match_all(string, trie):
matches = []
for i in range(len(string)):
substr = string[:(i + 1)]
if (not trie.has_prefix(substr)):
break
if (substr in trie):
matches.append(substr)
return matches
| [
"def",
"match_all",
"(",
"string",
",",
"trie",
")",
":",
"matches",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"string",
")",
")",
":",
"substr",
"=",
"string",
"[",
":",
"(",
"i",
"+",
"1",
")",
"]",
"if",
"(",
"not",
"trie"... | match_all -> list of keys find all the keys in the trie that matches the beginning of the string . | train | false |
10,081 | def email_reply():
from treeio.core.mail import IMAP_SERVER, EMAIL_USERNAME, EMAIL_PASSWORD
emailreplier = EmailReplier('IMAP-SSL', IMAP_SERVER, EMAIL_USERNAME, EMAIL_PASSWORD, getattr(settings, 'HARDTREE_MESSAGING_IMAP_DEFAULT_FOLDER_NAME', 'UNSEEN'))
emailreplier.get_emails()
| [
"def",
"email_reply",
"(",
")",
":",
"from",
"treeio",
".",
"core",
".",
"mail",
"import",
"IMAP_SERVER",
",",
"EMAIL_USERNAME",
",",
"EMAIL_PASSWORD",
"emailreplier",
"=",
"EmailReplier",
"(",
"'IMAP-SSL'",
",",
"IMAP_SERVER",
",",
"EMAIL_USERNAME",
",",
"EMAIL... | fetches emails . | train | false |
10,082 | def create_collection_summary(collection_id, contributor_id_to_add):
collection = get_collection_by_id(collection_id)
collection_summary = compute_summary_of_collection(collection, contributor_id_to_add)
save_collection_summary(collection_summary)
| [
"def",
"create_collection_summary",
"(",
"collection_id",
",",
"contributor_id_to_add",
")",
":",
"collection",
"=",
"get_collection_by_id",
"(",
"collection_id",
")",
"collection_summary",
"=",
"compute_summary_of_collection",
"(",
"collection",
",",
"contributor_id_to_add",... | creates and stores a summary of the given collection . | train | false |
10,083 | @require_GET
def ajax_status(request):
if (not request.user.is_authenticated()):
raise PermissionDenied
qs = UserPreference.objects.filter(user=request.user, key=NOTIFICATION_PREF_KEY)
return HttpResponse(json.dumps({'status': len(qs)}), content_type='application/json')
| [
"@",
"require_GET",
"def",
"ajax_status",
"(",
"request",
")",
":",
"if",
"(",
"not",
"request",
".",
"user",
".",
"is_authenticated",
"(",
")",
")",
":",
"raise",
"PermissionDenied",
"qs",
"=",
"UserPreference",
".",
"objects",
".",
"filter",
"(",
"user",... | a view that retrieves notifications status for the authenticated user . | train | false |
10,084 | def fourier_ellipsoid(input, size, n=(-1), axis=(-1), output=None):
input = numpy.asarray(input)
(output, return_value) = _get_output_fourier(output, input)
axis = _ni_support._check_axis(axis, input.ndim)
sizes = _ni_support._normalize_sequence(size, input.ndim)
sizes = numpy.asarray(sizes, dtype=numpy.float64)
if (not sizes.flags.contiguous):
sizes = sizes.copy()
_nd_image.fourier_filter(input, sizes, n, axis, output, 2)
return return_value
| [
"def",
"fourier_ellipsoid",
"(",
"input",
",",
"size",
",",
"n",
"=",
"(",
"-",
"1",
")",
",",
"axis",
"=",
"(",
"-",
"1",
")",
",",
"output",
"=",
"None",
")",
":",
"input",
"=",
"numpy",
".",
"asarray",
"(",
"input",
")",
"(",
"output",
",",
... | multi-dimensional ellipsoid fourier filter . | train | false |
10,085 | def delete_cache_subnet_group(name, region=None, key=None, keyid=None, profile=None, **args):
return _delete_resource(name, name_param='CacheSubnetGroupName', desc='cache subnet group', res_type='cache_subnet_group', region=region, key=key, keyid=keyid, profile=profile, **args)
| [
"def",
"delete_cache_subnet_group",
"(",
"name",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
",",
"**",
"args",
")",
":",
"return",
"_delete_resource",
"(",
"name",
",",
"name_param",
"=",
... | delete an elasticache subnet group . | train | true |
10,086 | def find_mapreduce_yaml(status_file=__file__):
checked = set()
yaml = _find_mapreduce_yaml(os.path.dirname(status_file), checked)
if (not yaml):
yaml = _find_mapreduce_yaml(os.getcwd(), checked)
return yaml
| [
"def",
"find_mapreduce_yaml",
"(",
"status_file",
"=",
"__file__",
")",
":",
"checked",
"=",
"set",
"(",
")",
"yaml",
"=",
"_find_mapreduce_yaml",
"(",
"os",
".",
"path",
".",
"dirname",
"(",
"status_file",
")",
",",
"checked",
")",
"if",
"(",
"not",
"ya... | traverse directory trees to find mapreduce . | train | true |
10,087 | def test_transform_output(argument_pair):
g = Expression.fromstring(argument_pair[0])
alist = [lp.parse(a) for a in argument_pair[1]]
m = MaceCommand(g, assumptions=alist)
m.build_model()
for a in alist:
print((' %s' % a))
print(('|- %s: %s\n' % (g, m.build_model())))
for format in ['standard', 'portable', 'xml', 'cooked']:
spacer()
print(("Using '%s' format" % format))
spacer()
print(m.model(format=format))
| [
"def",
"test_transform_output",
"(",
"argument_pair",
")",
":",
"g",
"=",
"Expression",
".",
"fromstring",
"(",
"argument_pair",
"[",
"0",
"]",
")",
"alist",
"=",
"[",
"lp",
".",
"parse",
"(",
"a",
")",
"for",
"a",
"in",
"argument_pair",
"[",
"1",
"]",... | transform the model into various mace4 interpformat formats . | train | false |
10,089 | def default_if_none(value, arg):
if (value is None):
return arg
return value
| [
"def",
"default_if_none",
"(",
"value",
",",
"arg",
")",
":",
"if",
"(",
"value",
"is",
"None",
")",
":",
"return",
"arg",
"return",
"value"
] | if value is none . | train | false |
10,090 | def find_or_none(key, search_maps, _map_index=0):
try:
attr = getattr(search_maps[_map_index], key)
return (attr if (attr is not None) else find_or_none(key, search_maps[1:]))
except AttributeError:
return find_or_none(key, search_maps, (_map_index + 1))
except IndexError:
return None
| [
"def",
"find_or_none",
"(",
"key",
",",
"search_maps",
",",
"_map_index",
"=",
"0",
")",
":",
"try",
":",
"attr",
"=",
"getattr",
"(",
"search_maps",
"[",
"_map_index",
"]",
",",
"key",
")",
"return",
"(",
"attr",
"if",
"(",
"attr",
"is",
"not",
"Non... | return the value of the first key found in the list of search_maps . | train | false |
10,091 | @task
def render_document_chunk(pks, cache_control='no-cache', base_url=None, force=False):
logger = render_document_chunk.get_logger()
logger.info((u'Starting to render document chunk: %s' % ','.join([str(pk) for pk in pks])))
base_url = (base_url or settings.SITE_URL)
for pk in pks:
result = render_document(pk, cache_control, base_url, force=force)
if result:
logger.error((u'Error while rendering document %s with error: %s' % (pk, result)))
logger.info(u'Finished rendering of document chunk')
| [
"@",
"task",
"def",
"render_document_chunk",
"(",
"pks",
",",
"cache_control",
"=",
"'no-cache'",
",",
"base_url",
"=",
"None",
",",
"force",
"=",
"False",
")",
":",
"logger",
"=",
"render_document_chunk",
".",
"get_logger",
"(",
")",
"logger",
".",
"info",
... | simple task to render a chunk of documents instead of one per each . | train | false |
10,092 | def getVersionString(version):
result = ('%s %s' % (version.package, version.short()))
return result
| [
"def",
"getVersionString",
"(",
"version",
")",
":",
"result",
"=",
"(",
"'%s %s'",
"%",
"(",
"version",
".",
"package",
",",
"version",
".",
"short",
"(",
")",
")",
")",
"return",
"result"
] | get a friendly string for the given version object . | train | false |
10,093 | def get_instance_uuid_by_ec2_id(context, ec2_id):
return IMPL.get_instance_uuid_by_ec2_id(context, ec2_id)
| [
"def",
"get_instance_uuid_by_ec2_id",
"(",
"context",
",",
"ec2_id",
")",
":",
"return",
"IMPL",
".",
"get_instance_uuid_by_ec2_id",
"(",
"context",
",",
"ec2_id",
")"
] | get uuid through ec2 id from instance_id_mappings table . | train | false |
10,094 | def setOptimize():
conf.keepAlive = True
conf.threads = (3 if (conf.threads < 3) else conf.threads)
conf.nullConnection = (not any((conf.data, conf.textOnly, conf.titles, conf.string, conf.notString, conf.regexp, conf.tor)))
if (not conf.nullConnection):
debugMsg = "turning off switch '--null-connection' used indirectly by switch '-o'"
logger.debug(debugMsg)
| [
"def",
"setOptimize",
"(",
")",
":",
"conf",
".",
"keepAlive",
"=",
"True",
"conf",
".",
"threads",
"=",
"(",
"3",
"if",
"(",
"conf",
".",
"threads",
"<",
"3",
")",
"else",
"conf",
".",
"threads",
")",
"conf",
".",
"nullConnection",
"=",
"(",
"not"... | sets options turned on by switch -o . | train | false |
10,095 | @register(u'next-history')
def next_history(event):
event.current_buffer.history_forward(count=event.arg)
| [
"@",
"register",
"(",
"u'next-history'",
")",
"def",
"next_history",
"(",
"event",
")",
":",
"event",
".",
"current_buffer",
".",
"history_forward",
"(",
"count",
"=",
"event",
".",
"arg",
")"
] | move forward through the history list . | train | false |
10,096 | def _read_byte(f):
return np.uint8(struct.unpack('>B', f.read(4)[:1])[0])
| [
"def",
"_read_byte",
"(",
"f",
")",
":",
"return",
"np",
".",
"uint8",
"(",
"struct",
".",
"unpack",
"(",
"'>B'",
",",
"f",
".",
"read",
"(",
"4",
")",
"[",
":",
"1",
"]",
")",
"[",
"0",
"]",
")"
] | read a single byte . | train | false |
10,097 | def test_ajd():
(n_times, n_channels) = (10, 3)
seed = np.random.RandomState(0)
diags = (2.0 + (0.1 * seed.randn(n_times, n_channels)))
A = ((2 * seed.rand(n_channels, n_channels)) - 1)
A /= np.atleast_2d(np.sqrt(np.sum((A ** 2), 1))).T
covmats = np.empty((n_times, n_channels, n_channels))
for i in range(n_times):
covmats[i] = np.dot(np.dot(A, np.diag(diags[i])), A.T)
(V, D) = _ajd_pham(covmats)
V_matlab = [[(-3.507280775058041), (-5.498189967306344), 7.720624541198574], [0.69468901323461, 0.775690358505945, (-1.162043086446043)], [(-0.592603135588066), (-0.59899692569626), 1.009550086271192]]
assert_array_almost_equal(V, V_matlab)
| [
"def",
"test_ajd",
"(",
")",
":",
"(",
"n_times",
",",
"n_channels",
")",
"=",
"(",
"10",
",",
"3",
")",
"seed",
"=",
"np",
".",
"random",
".",
"RandomState",
"(",
"0",
")",
"diags",
"=",
"(",
"2.0",
"+",
"(",
"0.1",
"*",
"seed",
".",
"randn",
... | test if approximate joint diagonalization implementation obtains same results as the matlab implementation by pham dinh-tuan . | train | false |
10,098 | def init_state_collection(state, dict_, key):
attr = state.manager[key].impl
user_data = attr.initialize(state, dict_)
return attr.get_collection(state, dict_, user_data)
| [
"def",
"init_state_collection",
"(",
"state",
",",
"dict_",
",",
"key",
")",
":",
"attr",
"=",
"state",
".",
"manager",
"[",
"key",
"]",
".",
"impl",
"user_data",
"=",
"attr",
".",
"initialize",
"(",
"state",
",",
"dict_",
")",
"return",
"attr",
".",
... | initialize a collection attribute and return the collection adapter . | train | false |
10,099 | def _item_to_changes(iterator, resource):
return Changes.from_api_repr(resource, iterator.zone)
| [
"def",
"_item_to_changes",
"(",
"iterator",
",",
"resource",
")",
":",
"return",
"Changes",
".",
"from_api_repr",
"(",
"resource",
",",
"iterator",
".",
"zone",
")"
] | convert a json "changes" value to the native object . | train | false |
10,100 | def set_sync(value):
return set_var('SYNC', value)
| [
"def",
"set_sync",
"(",
"value",
")",
":",
"return",
"set_var",
"(",
"'SYNC'",
",",
"value",
")"
] | set the sync variable return a dict containing the new value for variable:: {<variable>: {old: <old-value> . | train | false |
10,101 | def get_task_logger(name):
if (name in RESERVED_LOGGER_NAMES):
raise RuntimeError(u'Logger name {0!r} is reserved!'.format(name))
return _using_logger_parent(task_logger, get_logger(name))
| [
"def",
"get_task_logger",
"(",
"name",
")",
":",
"if",
"(",
"name",
"in",
"RESERVED_LOGGER_NAMES",
")",
":",
"raise",
"RuntimeError",
"(",
"u'Logger name {0!r} is reserved!'",
".",
"format",
"(",
"name",
")",
")",
"return",
"_using_logger_parent",
"(",
"task_logge... | get logger for task module by name . | train | false |
10,102 | def is_ec2_timestamp_expired(request, expires=None):
timestamp = request.get('Timestamp')
expiry_time = request.get('Expires')
def parse_strtime(strtime):
if _ms_time_regex.match(strtime):
time_format = '%Y-%m-%dT%H:%M:%S.%fZ'
else:
time_format = '%Y-%m-%dT%H:%M:%SZ'
return timeutils.parse_strtime(strtime, time_format)
try:
if (timestamp and expiry_time):
msg = _('Request must include either Timestamp or Expires, but cannot contain both')
LOG.error(msg)
raise exception.InvalidRequest(msg)
elif expiry_time:
query_time = parse_strtime(expiry_time)
return timeutils.is_older_than(query_time, (-1))
elif timestamp:
query_time = parse_strtime(timestamp)
if (query_time and expires):
return (timeutils.is_older_than(query_time, expires) or timeutils.is_newer_than(query_time, expires))
return False
except ValueError:
LOG.info(_LI('Timestamp is invalid.'))
return True
| [
"def",
"is_ec2_timestamp_expired",
"(",
"request",
",",
"expires",
"=",
"None",
")",
":",
"timestamp",
"=",
"request",
".",
"get",
"(",
"'Timestamp'",
")",
"expiry_time",
"=",
"request",
".",
"get",
"(",
"'Expires'",
")",
"def",
"parse_strtime",
"(",
"strtim... | checks the timestamp or expiry time included in an ec2 request and returns true if the request is expired . | train | false |
10,103 | def unbind_floating_ip(floating_ip, device):
_execute('ip', 'addr', 'del', (str(floating_ip) + '/32'), 'dev', device, run_as_root=True, check_exit_code=[0, 2, 254])
| [
"def",
"unbind_floating_ip",
"(",
"floating_ip",
",",
"device",
")",
":",
"_execute",
"(",
"'ip'",
",",
"'addr'",
",",
"'del'",
",",
"(",
"str",
"(",
"floating_ip",
")",
"+",
"'/32'",
")",
",",
"'dev'",
",",
"device",
",",
"run_as_root",
"=",
"True",
"... | unbind a public ip from public interface . | train | false |
10,106 | def get_scale(x):
scales = [20, 50, 100, 200, 400, 600, 800, 1000]
for scale in scales:
if (x <= scale):
return scale
return x
| [
"def",
"get_scale",
"(",
"x",
")",
":",
"scales",
"=",
"[",
"20",
",",
"50",
",",
"100",
",",
"200",
",",
"400",
",",
"600",
",",
"800",
",",
"1000",
"]",
"for",
"scale",
"in",
"scales",
":",
"if",
"(",
"x",
"<=",
"scale",
")",
":",
"return",... | finds the lowest scale where x <= scale . | train | false |
10,108 | def set_items(widget, items):
widget.clear()
add_items(widget, items)
| [
"def",
"set_items",
"(",
"widget",
",",
"items",
")",
":",
"widget",
".",
"clear",
"(",
")",
"add_items",
"(",
"widget",
",",
"items",
")"
] | clear the existing widget contents and set the new items . | train | false |
10,109 | @dec.skipif_not_numpy
def test_numpy_reset_array_undec():
_ip.ex('import numpy as np')
_ip.ex('a = np.empty(2)')
nt.assert_in('a', _ip.user_ns)
_ip.magic('reset -f array')
nt.assert_not_in('a', _ip.user_ns)
| [
"@",
"dec",
".",
"skipif_not_numpy",
"def",
"test_numpy_reset_array_undec",
"(",
")",
":",
"_ip",
".",
"ex",
"(",
"'import numpy as np'",
")",
"_ip",
".",
"ex",
"(",
"'a = np.empty(2)'",
")",
"nt",
".",
"assert_in",
"(",
"'a'",
",",
"_ip",
".",
"user_ns",
... | test %reset array functionality . | train | false |
10,110 | def CDLLONGLEGGEDDOJI(barDs, count):
return call_talib_with_ohlc(barDs, count, talib.CDLLONGLEGGEDDOJI)
| [
"def",
"CDLLONGLEGGEDDOJI",
"(",
"barDs",
",",
"count",
")",
":",
"return",
"call_talib_with_ohlc",
"(",
"barDs",
",",
"count",
",",
"talib",
".",
"CDLLONGLEGGEDDOJI",
")"
] | long legged doji . | train | false |
10,111 | def test_step_represent_matrix():
step = core.Step.from_string(STEP_WITH_MATRIX2)
assert_equals(step.represent_columns(), ' | a | a |\n | 2 | a |\n | | 67|\n')
| [
"def",
"test_step_represent_matrix",
"(",
")",
":",
"step",
"=",
"core",
".",
"Step",
".",
"from_string",
"(",
"STEP_WITH_MATRIX2",
")",
"assert_equals",
"(",
"step",
".",
"represent_columns",
"(",
")",
",",
"' | a | a |\\n | 2 | a |\\n | | 67|\\n'",
... | step with a more suggestive representation for a matrix . | train | false |
10,113 | def F_from_ransac(x1, x2, model, maxiter=5000, match_theshold=1e-06):
import ransac
data = vstack((x1, x2))
(F, ransac_data) = ransac.ransac(data.T, model, 8, maxiter, match_theshold, 20, return_all=True)
return (F, ransac_data['inliers'])
| [
"def",
"F_from_ransac",
"(",
"x1",
",",
"x2",
",",
"model",
",",
"maxiter",
"=",
"5000",
",",
"match_theshold",
"=",
"1e-06",
")",
":",
"import",
"ransac",
"data",
"=",
"vstack",
"(",
"(",
"x1",
",",
"x2",
")",
")",
"(",
"F",
",",
"ransac_data",
")... | robust estimation of a fundamental matrix f from point correspondences using ransac . | train | false |
10,114 | def toplevel(func):
synctaskletfunc = synctasklet(func)
@utils.wrapping(func)
def add_context_wrapper(*args, **kwds):
__ndb_debug__ = utils.func_info(func)
_state.clear_all_pending()
ctx = make_default_context()
try:
set_context(ctx)
return synctaskletfunc(*args, **kwds)
finally:
set_context(None)
ctx.flush().check_success()
eventloop.run()
return add_context_wrapper
| [
"def",
"toplevel",
"(",
"func",
")",
":",
"synctaskletfunc",
"=",
"synctasklet",
"(",
"func",
")",
"@",
"utils",
".",
"wrapping",
"(",
"func",
")",
"def",
"add_context_wrapper",
"(",
"*",
"args",
",",
"**",
"kwds",
")",
":",
"__ndb_debug__",
"=",
"utils"... | a sync tasklet that sets a fresh default context . | train | true |
10,115 | def config_auto_int_value(value, default):
if ((value is None) or (isinstance(value, six.string_types) and (value.lower() == 'auto'))):
return default
try:
value = int(value)
except (TypeError, ValueError):
raise ValueError(('Config option must be an integer or the string "auto", not "%s".' % value))
return value
| [
"def",
"config_auto_int_value",
"(",
"value",
",",
"default",
")",
":",
"if",
"(",
"(",
"value",
"is",
"None",
")",
"or",
"(",
"isinstance",
"(",
"value",
",",
"six",
".",
"string_types",
")",
"and",
"(",
"value",
".",
"lower",
"(",
")",
"==",
"'auto... | returns default if value is none or auto . | train | false |
10,116 | def getDOMImplementation(name=None, features=()):
import os
creator = None
mod = well_known_implementations.get(name)
if mod:
mod = __import__(mod, {}, {}, ['getDOMImplementation'])
return mod.getDOMImplementation()
elif name:
return registered[name]()
elif ('PYTHON_DOM' in os.environ):
return getDOMImplementation(name=os.environ['PYTHON_DOM'])
if isinstance(features, str):
features = _parse_feature_string(features)
for creator in registered.values():
dom = creator()
if _good_enough(dom, features):
return dom
for creator in well_known_implementations.keys():
try:
dom = getDOMImplementation(name=creator)
except Exception:
continue
if _good_enough(dom, features):
return dom
raise ImportError('no suitable DOM implementation found')
| [
"def",
"getDOMImplementation",
"(",
"name",
"=",
"None",
",",
"features",
"=",
"(",
")",
")",
":",
"import",
"os",
"creator",
"=",
"None",
"mod",
"=",
"well_known_implementations",
".",
"get",
"(",
"name",
")",
"if",
"mod",
":",
"mod",
"=",
"__import__",... | getdomimplementation(name = none . | train | false |
10,119 | def get_references(file_name, encoding='utf-8'):
text = ''
if (file_name is not None):
if os.path.exists(file_name):
try:
with codecs.open(file_name, 'r', encoding=encoding) as f:
text = f.read()
except:
print traceback.format_exc()
else:
print ('Could not find reference file %s!', file_name)
return text
| [
"def",
"get_references",
"(",
"file_name",
",",
"encoding",
"=",
"'utf-8'",
")",
":",
"text",
"=",
"''",
"if",
"(",
"file_name",
"is",
"not",
"None",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"file_name",
")",
":",
"try",
":",
"with",
... | get footnote and general references from outside source . | train | false |
10,121 | @login_required
def view_survey(request, survey_name):
redirect_url = request.GET.get('redirect_url')
return view_student_survey(request.user, survey_name, redirect_url=redirect_url)
| [
"@",
"login_required",
"def",
"view_survey",
"(",
"request",
",",
"survey_name",
")",
":",
"redirect_url",
"=",
"request",
".",
"GET",
".",
"get",
"(",
"'redirect_url'",
")",
"return",
"view_student_survey",
"(",
"request",
".",
"user",
",",
"survey_name",
","... | view to render the survey to the end user . | train | false |
10,123 | def mapto_v6(addr):
try:
inet_pton(socket.AF_INET, addr)
return '::ffff:{}'.format(addr)
except socket.error:
try:
inet_pton(socket.AF_INET6, addr)
return addr
except socket.error:
log.debug('%s is not a valid IP address.', addr)
return None
| [
"def",
"mapto_v6",
"(",
"addr",
")",
":",
"try",
":",
"inet_pton",
"(",
"socket",
".",
"AF_INET",
",",
"addr",
")",
"return",
"'::ffff:{}'",
".",
"format",
"(",
"addr",
")",
"except",
"socket",
".",
"error",
":",
"try",
":",
"inet_pton",
"(",
"socket",... | map an ipv4 address to an ipv6 one . | train | false |
10,124 | def wrap_socket(sock, keyfile=None, certfile=None, server_side=False, cert_reqs=CERT_NONE, ssl_version=PROTOCOL_SSLv23, ca_certs=None, do_handshake_on_connect=True, suppress_ragged_eofs=True, ciphers=None):
return SSLSocket(sock, keyfile=keyfile, certfile=certfile, server_side=server_side, cert_reqs=cert_reqs, ssl_version=ssl_version, ca_certs=ca_certs, do_handshake_on_connect=do_handshake_on_connect, suppress_ragged_eofs=suppress_ragged_eofs, ciphers=ciphers)
| [
"def",
"wrap_socket",
"(",
"sock",
",",
"keyfile",
"=",
"None",
",",
"certfile",
"=",
"None",
",",
"server_side",
"=",
"False",
",",
"cert_reqs",
"=",
"CERT_NONE",
",",
"ssl_version",
"=",
"PROTOCOL_SSLv23",
",",
"ca_certs",
"=",
"None",
",",
"do_handshake_o... | create a new :class:sslobject instance . | train | false |
10,125 | def tight_layout(pad=1.2, h_pad=None, w_pad=None, fig=None):
import matplotlib.pyplot as plt
fig = (plt.gcf() if (fig is None) else fig)
fig.canvas.draw()
try:
fig.tight_layout(pad=pad, h_pad=h_pad, w_pad=w_pad)
except Exception:
try:
fig.set_tight_layout(dict(pad=pad, h_pad=h_pad, w_pad=w_pad))
except Exception:
warn('Matplotlib function "tight_layout" is not supported. Skipping subplot adjustment.')
| [
"def",
"tight_layout",
"(",
"pad",
"=",
"1.2",
",",
"h_pad",
"=",
"None",
",",
"w_pad",
"=",
"None",
",",
"fig",
"=",
"None",
")",
":",
"import",
"matplotlib",
".",
"pyplot",
"as",
"plt",
"fig",
"=",
"(",
"plt",
".",
"gcf",
"(",
")",
"if",
"(",
... | automatically adjust subplot parameters to give specified padding . | train | false |
10,127 | @raises(ValueError)
def test_raises_value_error_non_2dim():
gth_solve(np.array([0.4, 0.6]))
| [
"@",
"raises",
"(",
"ValueError",
")",
"def",
"test_raises_value_error_non_2dim",
"(",
")",
":",
"gth_solve",
"(",
"np",
".",
"array",
"(",
"[",
"0.4",
",",
"0.6",
"]",
")",
")"
] | test with non 2dim input . | train | false |
10,128 | def get_axis_properties(axis):
props = {}
label1On = axis._major_tick_kw.get('label1On', True)
if isinstance(axis, matplotlib.axis.XAxis):
if label1On:
props['position'] = 'bottom'
else:
props['position'] = 'top'
elif isinstance(axis, matplotlib.axis.YAxis):
if label1On:
props['position'] = 'left'
else:
props['position'] = 'right'
else:
raise ValueError('{0} should be an Axis instance'.format(axis))
locator = axis.get_major_locator()
props['nticks'] = len(locator())
if isinstance(locator, ticker.FixedLocator):
props['tickvalues'] = list(locator())
else:
props['tickvalues'] = None
formatter = axis.get_major_formatter()
if isinstance(formatter, ticker.NullFormatter):
props['tickformat'] = ''
elif isinstance(formatter, ticker.FixedFormatter):
props['tickformat'] = list(formatter.seq)
elif (not any((label.get_visible() for label in axis.get_ticklabels()))):
props['tickformat'] = ''
else:
props['tickformat'] = None
props['scale'] = axis.get_scale()
labels = axis.get_ticklabels()
if labels:
props['fontsize'] = labels[0].get_fontsize()
else:
props['fontsize'] = None
props['grid'] = get_grid_style(axis)
props['visible'] = axis.get_visible()
return props
| [
"def",
"get_axis_properties",
"(",
"axis",
")",
":",
"props",
"=",
"{",
"}",
"label1On",
"=",
"axis",
".",
"_major_tick_kw",
".",
"get",
"(",
"'label1On'",
",",
"True",
")",
"if",
"isinstance",
"(",
"axis",
",",
"matplotlib",
".",
"axis",
".",
"XAxis",
... | return the property dictionary for a matplotlib . | train | true |
10,132 | def _ci(arr, ci):
from scipy import stats
(mean, sigma) = (arr.mean(0), stats.sem(arr, 0))
return np.asarray([stats.t.interval(ci, arr.shape[0], loc=mean_, scale=sigma_) for (mean_, sigma_) in zip(mean, sigma)]).T
| [
"def",
"_ci",
"(",
"arr",
",",
"ci",
")",
":",
"from",
"scipy",
"import",
"stats",
"(",
"mean",
",",
"sigma",
")",
"=",
"(",
"arr",
".",
"mean",
"(",
"0",
")",
",",
"stats",
".",
"sem",
"(",
"arr",
",",
"0",
")",
")",
"return",
"np",
".",
"... | calculate the ci% parametric confidence interval for arr . | train | false |
10,134 | def PearsonMedianSkewness(xs):
median = Median(xs)
mean = RawMoment(xs, 1)
var = CentralMoment(xs, 2)
std = math.sqrt(var)
gp = ((3 * (mean - median)) / std)
return gp
| [
"def",
"PearsonMedianSkewness",
"(",
"xs",
")",
":",
"median",
"=",
"Median",
"(",
"xs",
")",
"mean",
"=",
"RawMoment",
"(",
"xs",
",",
"1",
")",
"var",
"=",
"CentralMoment",
"(",
"xs",
",",
"2",
")",
"std",
"=",
"math",
".",
"sqrt",
"(",
"var",
... | computes the pearson median skewness . | train | false |
10,135 | def _retry_exception_async(reactor, f, steps=((0.1,) * 10)):
saved_failure = [None]
saved_result = [None]
def handle_success(result):
saved_result[0] = result
return True
def handle_failure(failure):
Message.log(message_type=u'flocker:provision:libcloud:retry_exception:got_exception')
write_failure(failure)
saved_failure[0] = failure
return False
def make_call():
d = maybeDeferred(f)
d = DeferredContext(d)
d.addCallbacks(handle_success, errback=handle_failure)
return d.result
action = start_action(action_type=u'flocker:provision:libcloud:retry_exception', function=function_serializer(f))
with action.context():
d = loop_until(reactor, make_call, steps)
d = DeferredContext(d)
d.addCallbacks((lambda _: saved_result[0]), errback=(lambda _: saved_failure[0]))
return d.addActionFinish()
| [
"def",
"_retry_exception_async",
"(",
"reactor",
",",
"f",
",",
"steps",
"=",
"(",
"(",
"0.1",
",",
")",
"*",
"10",
")",
")",
":",
"saved_failure",
"=",
"[",
"None",
"]",
"saved_result",
"=",
"[",
"None",
"]",
"def",
"handle_success",
"(",
"result",
... | retry a function if it raises an exception . | train | false |
10,136 | def fractional_matrix_power(A, t):
A = _asarray_square(A)
import scipy.linalg._matfuncs_inv_ssq
return scipy.linalg._matfuncs_inv_ssq._fractional_matrix_power(A, t)
| [
"def",
"fractional_matrix_power",
"(",
"A",
",",
"t",
")",
":",
"A",
"=",
"_asarray_square",
"(",
"A",
")",
"import",
"scipy",
".",
"linalg",
".",
"_matfuncs_inv_ssq",
"return",
"scipy",
".",
"linalg",
".",
"_matfuncs_inv_ssq",
".",
"_fractional_matrix_power",
... | compute the fractional power of a matrix . | train | false |
10,137 | def removeSVGFile(svgFilePath):
if archive.getEndsWithList(svgFilePath, ['_bottom.svg', '_carve.svg', '_chop.svg', '_cleave.svg', '_scale.svg', '_vectorwrite.svg']):
os.remove(svgFilePath)
print ('removeGeneratedFiles deleted ' + svgFilePath)
| [
"def",
"removeSVGFile",
"(",
"svgFilePath",
")",
":",
"if",
"archive",
".",
"getEndsWithList",
"(",
"svgFilePath",
",",
"[",
"'_bottom.svg'",
",",
"'_carve.svg'",
",",
"'_chop.svg'",
",",
"'_cleave.svg'",
",",
"'_scale.svg'",
",",
"'_vectorwrite.svg'",
"]",
")",
... | remove svg file . | train | false |
10,138 | def _add_current_user_id(graph, user):
if graph:
graph.current_user_id = None
if user.is_authenticated():
profile = try_get_profile(user)
facebook_id = get_user_attribute(user, profile, 'facebook_id')
if facebook_id:
graph.current_user_id = facebook_id
| [
"def",
"_add_current_user_id",
"(",
"graph",
",",
"user",
")",
":",
"if",
"graph",
":",
"graph",
".",
"current_user_id",
"=",
"None",
"if",
"user",
".",
"is_authenticated",
"(",
")",
":",
"profile",
"=",
"try_get_profile",
"(",
"user",
")",
"facebook_id",
... | set the current user id . | train | false |
10,139 | def filldedent(s, w=70):
return ('\n' + fill(dedent(str(s)).strip('\n'), width=w))
| [
"def",
"filldedent",
"(",
"s",
",",
"w",
"=",
"70",
")",
":",
"return",
"(",
"'\\n'",
"+",
"fill",
"(",
"dedent",
"(",
"str",
"(",
"s",
")",
")",
".",
"strip",
"(",
"'\\n'",
")",
",",
"width",
"=",
"w",
")",
")"
] | strips leading and trailing empty lines from a copy of s . | train | false |
10,140 | def _is_1(expr):
try:
v = opt.get_scalar_constant_value(expr)
return numpy.allclose(v, 1)
except tensor.NotScalarConstantError:
return False
| [
"def",
"_is_1",
"(",
"expr",
")",
":",
"try",
":",
"v",
"=",
"opt",
".",
"get_scalar_constant_value",
"(",
"expr",
")",
"return",
"numpy",
".",
"allclose",
"(",
"v",
",",
"1",
")",
"except",
"tensor",
".",
"NotScalarConstantError",
":",
"return",
"False"... | returns bool true iff expr is a constant close to 1 . | train | false |
10,141 | def get_preview_fragment(request, descriptor, context):
module = _load_preview_module(request, descriptor)
preview_view = (AUTHOR_VIEW if has_author_view(module) else STUDENT_VIEW)
try:
fragment = module.render(preview_view, context)
except Exception as exc:
log.warning('Unable to render %s for %r', preview_view, module, exc_info=True)
fragment = Fragment(render_to_string('html_error.html', {'message': str(exc)}))
return fragment
| [
"def",
"get_preview_fragment",
"(",
"request",
",",
"descriptor",
",",
"context",
")",
":",
"module",
"=",
"_load_preview_module",
"(",
"request",
",",
"descriptor",
")",
"preview_view",
"=",
"(",
"AUTHOR_VIEW",
"if",
"has_author_view",
"(",
"module",
")",
"else... | returns the html returned by the xmodules student_view or author_view . | train | false |
10,142 | def test_ensure_list():
schema = vol.Schema(cv.ensure_list)
assert ([] == schema(None))
assert ([1] == schema(1))
assert ([1] == schema([1]))
assert (['1'] == schema('1'))
assert (['1'] == schema(['1']))
assert ([{'1': '2'}] == schema({'1': '2'}))
| [
"def",
"test_ensure_list",
"(",
")",
":",
"schema",
"=",
"vol",
".",
"Schema",
"(",
"cv",
".",
"ensure_list",
")",
"assert",
"(",
"[",
"]",
"==",
"schema",
"(",
"None",
")",
")",
"assert",
"(",
"[",
"1",
"]",
"==",
"schema",
"(",
"1",
")",
")",
... | test ensure_list . | train | false |
10,143 | def first_diff(a, b):
i = (-1)
for i in xrange(0, len(a)):
if (a[i] != b[1]):
return i
if (i == 255):
return i
| [
"def",
"first_diff",
"(",
"a",
",",
"b",
")",
":",
"i",
"=",
"(",
"-",
"1",
")",
"for",
"i",
"in",
"xrange",
"(",
"0",
",",
"len",
"(",
"a",
")",
")",
":",
"if",
"(",
"a",
"[",
"i",
"]",
"!=",
"b",
"[",
"1",
"]",
")",
":",
"return",
"... | returns the position of the first differing character in the strings a and b . | train | false |
10,145 | def _check_window_params(data, window_length):
if (window_length < 1):
raise WindowLengthNotPositive(window_length=window_length)
if (window_length > data.shape[0]):
raise WindowLengthTooLong(nrows=data.shape[0], window_length=window_length)
| [
"def",
"_check_window_params",
"(",
"data",
",",
"window_length",
")",
":",
"if",
"(",
"window_length",
"<",
"1",
")",
":",
"raise",
"WindowLengthNotPositive",
"(",
"window_length",
"=",
"window_length",
")",
"if",
"(",
"window_length",
">",
"data",
".",
"shap... | check that a window of length window_length is well-defined on data . | train | true |
10,146 | def test_multiple_subordinate_steps_are_run():
@step('I run two subordinate steps')
def two_subordinate_steps(step):
step.behave_as('\n When I run the first sub-step\n And I run the second sub-step\n ')
global first_ran
global second_ran
first_ran = False
second_ran = False
@step('I run the first sub-step$')
def increment(step):
global first_ran
first_ran = True
@step('I run the second sub-step')
def increment_twice(step):
global second_ran
second_ran = True
runnable_step = Step.from_string('Given I run two subordinate steps')
runnable_step.run(True)
assert_equals((first_ran, second_ran), (True, True))
del first_ran
del second_ran
| [
"def",
"test_multiple_subordinate_steps_are_run",
"(",
")",
":",
"@",
"step",
"(",
"'I run two subordinate steps'",
")",
"def",
"two_subordinate_steps",
"(",
"step",
")",
":",
"step",
".",
"behave_as",
"(",
"'\\n When I run the first sub-step\\n And I ru... | when a step definition calls two subordinate step definitions . | train | false |
10,147 | def default_listener(col_attr, default):
@event.listens_for(col_attr, 'init_scalar', retval=True, propagate=True)
def init_scalar(target, value, dict_):
if default.is_callable:
value = default.arg(None)
elif default.is_scalar:
value = default.arg
else:
raise NotImplementedError("Can't invoke pre-default for a SQL-level column default")
dict_[col_attr.key] = value
return value
| [
"def",
"default_listener",
"(",
"col_attr",
",",
"default",
")",
":",
"@",
"event",
".",
"listens_for",
"(",
"col_attr",
",",
"'init_scalar'",
",",
"retval",
"=",
"True",
",",
"propagate",
"=",
"True",
")",
"def",
"init_scalar",
"(",
"target",
",",
"value"... | establish a default-setting listener . | train | true |
10,148 | def get_dataset(name, split_name, dataset_dir, file_pattern=None, reader=None):
if (name not in datasets_map):
raise ValueError(('Name of dataset unknown %s' % name))
return datasets_map[name].get_split(split_name, dataset_dir, file_pattern, reader)
| [
"def",
"get_dataset",
"(",
"name",
",",
"split_name",
",",
"dataset_dir",
",",
"file_pattern",
"=",
"None",
",",
"reader",
"=",
"None",
")",
":",
"if",
"(",
"name",
"not",
"in",
"datasets_map",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'Name of dataset u... | given a dataset name and a split_name returns a dataset . | train | false |
10,149 | def _verify_bsgs(group, base, gens):
from sympy.combinatorics.perm_groups import PermutationGroup
strong_gens_distr = _distribute_gens_by_base(base, gens)
current_stabilizer = group
for i in range(len(base)):
candidate = PermutationGroup(strong_gens_distr[i])
if (current_stabilizer.order() != candidate.order()):
return False
current_stabilizer = current_stabilizer.stabilizer(base[i])
if (current_stabilizer.order() != 1):
return False
return True
| [
"def",
"_verify_bsgs",
"(",
"group",
",",
"base",
",",
"gens",
")",
":",
"from",
"sympy",
".",
"combinatorics",
".",
"perm_groups",
"import",
"PermutationGroup",
"strong_gens_distr",
"=",
"_distribute_gens_by_base",
"(",
"base",
",",
"gens",
")",
"current_stabiliz... | verify the correctness of a base and strong generating set . | train | false |
10,150 | def cornacchia(a, b, m):
sols = set()
a1 = igcdex(a, m)[0]
v = sqrt_mod(((- b) * a1), m, all_roots=True)
if (not v):
return None
for t in v:
if (t < (m // 2)):
continue
(u, r) = (t, m)
while True:
(u, r) = (r, (u % r))
if ((a * (r ** 2)) < m):
break
m1 = (m - (a * (r ** 2)))
if ((m1 % b) == 0):
m1 = (m1 // b)
(s, _exact) = integer_nthroot(m1, 2)
if _exact:
if ((a == b) and (r < s)):
(r, s) = (s, r)
sols.add((int(r), int(s)))
return sols
| [
"def",
"cornacchia",
"(",
"a",
",",
"b",
",",
"m",
")",
":",
"sols",
"=",
"set",
"(",
")",
"a1",
"=",
"igcdex",
"(",
"a",
",",
"m",
")",
"[",
"0",
"]",
"v",
"=",
"sqrt_mod",
"(",
"(",
"(",
"-",
"b",
")",
"*",
"a1",
")",
",",
"m",
",",
... | solves ax^2 + by^2 = m where gcd = 1 = gcd and a . | train | false |
10,151 | def cubehelix_palette(n_colors=6, start=0, rot=0.4, gamma=1.0, hue=0.8, light=0.85, dark=0.15, reverse=False, as_cmap=False):
cdict = mpl._cm.cubehelix(gamma, start, rot, hue)
cmap = mpl.colors.LinearSegmentedColormap('cubehelix', cdict)
x = np.linspace(light, dark, n_colors)
pal = cmap(x)[:, :3].tolist()
if reverse:
pal = pal[::(-1)]
if as_cmap:
x_256 = np.linspace(light, dark, 256)
if reverse:
x_256 = x_256[::(-1)]
pal_256 = cmap(x_256)
cmap = mpl.colors.ListedColormap(pal_256)
return cmap
else:
return _ColorPalette(pal)
| [
"def",
"cubehelix_palette",
"(",
"n_colors",
"=",
"6",
",",
"start",
"=",
"0",
",",
"rot",
"=",
"0.4",
",",
"gamma",
"=",
"1.0",
",",
"hue",
"=",
"0.8",
",",
"light",
"=",
"0.85",
",",
"dark",
"=",
"0.15",
",",
"reverse",
"=",
"False",
",",
"as_c... | make a sequential palette from the cubehelix system . | train | true |
10,152 | def coset_enumeration_r(fp_grp, Y):
C = CosetTable(fp_grp, Y)
R = fp_grp.relators()
A_dict = C.A_dict
A_dict_inv = C.A_dict_inv
p = C.p
for w in Y:
C.scan_and_fill(0, w)
alpha = 0
while (alpha < C.n):
if (p[alpha] == alpha):
for w in R:
C.scan_and_fill(alpha, w)
if (p[alpha] < alpha):
break
if (p[alpha] == alpha):
for x in A_dict:
if (C.table[alpha][A_dict[x]] is None):
C.define(alpha, x)
alpha += 1
return C
| [
"def",
"coset_enumeration_r",
"(",
"fp_grp",
",",
"Y",
")",
":",
"C",
"=",
"CosetTable",
"(",
"fp_grp",
",",
"Y",
")",
"R",
"=",
"fp_grp",
".",
"relators",
"(",
")",
"A_dict",
"=",
"C",
".",
"A_dict",
"A_dict_inv",
"=",
"C",
".",
"A_dict_inv",
"p",
... | this is easier of the two implemented methods of coset enumeration . | train | false |
10,156 | def lopen_loc(x):
lineno = (x._lopen_lineno if hasattr(x, '_lopen_lineno') else x.lineno)
col = (x._lopen_col if hasattr(x, '_lopen_col') else x.col_offset)
return (lineno, col)
| [
"def",
"lopen_loc",
"(",
"x",
")",
":",
"lineno",
"=",
"(",
"x",
".",
"_lopen_lineno",
"if",
"hasattr",
"(",
"x",
",",
"'_lopen_lineno'",
")",
"else",
"x",
".",
"lineno",
")",
"col",
"=",
"(",
"x",
".",
"_lopen_col",
"if",
"hasattr",
"(",
"x",
",",... | extracts the line and column number for a node that may have anb opening parenthesis . | train | false |
10,157 | def update_dir_prior(prior, N, logphat, rho):
dprior = np.copy(prior)
gradf = (N * ((psi(np.sum(prior)) - psi(prior)) + logphat))
c = (N * polygamma(1, np.sum(prior)))
q = ((- N) * polygamma(1, prior))
b = (np.sum((gradf / q)) / ((1 / c) + np.sum((1 / q))))
dprior = ((- (gradf - b)) / q)
if all((((rho * dprior) + prior) > 0)):
prior += (rho * dprior)
else:
logger.warning('updated prior not positive')
return prior
| [
"def",
"update_dir_prior",
"(",
"prior",
",",
"N",
",",
"logphat",
",",
"rho",
")",
":",
"dprior",
"=",
"np",
".",
"copy",
"(",
"prior",
")",
"gradf",
"=",
"(",
"N",
"*",
"(",
"(",
"psi",
"(",
"np",
".",
"sum",
"(",
"prior",
")",
")",
"-",
"p... | updates a given prior using newtons method . | train | false |
10,160 | def _CheckLimit(limit):
return _CheckInteger(limit, 'limit', zero_ok=False, upper_bound=MAXIMUM_DOCUMENTS_RETURNED_PER_SEARCH)
| [
"def",
"_CheckLimit",
"(",
"limit",
")",
":",
"return",
"_CheckInteger",
"(",
"limit",
",",
"'limit'",
",",
"zero_ok",
"=",
"False",
",",
"upper_bound",
"=",
"MAXIMUM_DOCUMENTS_RETURNED_PER_SEARCH",
")"
] | checks the limit of documents to return is an integer within range . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.