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 |
|---|---|---|---|---|---|
5,799 | def _ensure_unicode(text):
if isinstance(text, bytes):
text = text.decode(u'utf-8')
return text
| [
"def",
"_ensure_unicode",
"(",
"text",
")",
":",
"if",
"isinstance",
"(",
"text",
",",
"bytes",
")",
":",
"text",
"=",
"text",
".",
"decode",
"(",
"u'utf-8'",
")",
"return",
"text"
] | return a unicode object for the given text . | train | false |
5,801 | def xml_name(p, keep_escape=False, encoding=None):
if isinstance(p, unicode):
pass
elif isinstance(p, str):
if (sabnzbd.DARWIN or (encoding == 'utf-8')):
p = p.decode('utf-8', 'replace')
elif gUTF:
p = p.decode('utf-8', 'replace')
else:
p = p.decode(codepage, 'replace')
else:
p = str(p)
if keep_escape:
return p.encode('ascii', 'xmlcharrefreplace')
else:
return escape(p).encode('ascii', 'xmlcharrefreplace')
| [
"def",
"xml_name",
"(",
"p",
",",
"keep_escape",
"=",
"False",
",",
"encoding",
"=",
"None",
")",
":",
"if",
"isinstance",
"(",
"p",
",",
"unicode",
")",
":",
"pass",
"elif",
"isinstance",
"(",
"p",
",",
"str",
")",
":",
"if",
"(",
"sabnzbd",
".",
... | prepare name for use in html/xml contect . | train | false |
5,802 | def download_UCLUST():
status('Installing UCLUST...')
if (sys.platform == 'darwin'):
URL = 'http://www.drive5.com/uclust/uclustq1.2.22_i86darwin64'
elif (sys.platform == 'linux2'):
URL = 'http://www.drive5.com/uclust/uclustq1.2.22_i86linux64'
else:
status(('Platform %r not supported by UCLUST.\n' % sys.platform))
return
return_value = download_file(URL, 'scripts/', 'uclust')
if (not return_value):
chmod('scripts/uclust', (stat('scripts/uclust').st_mode | S_IEXEC))
status('UCLUST installed.\n')
else:
status('UCLUST could not be installed.\n')
| [
"def",
"download_UCLUST",
"(",
")",
":",
"status",
"(",
"'Installing UCLUST...'",
")",
"if",
"(",
"sys",
".",
"platform",
"==",
"'darwin'",
")",
":",
"URL",
"=",
"'http://www.drive5.com/uclust/uclustq1.2.22_i86darwin64'",
"elif",
"(",
"sys",
".",
"platform",
"==",... | download the uclust executable and set it to the scripts directory . | train | false |
5,803 | def make_pad_parameters(curve_value, threshold_value):
threshold_range = (MAX_THRESHOLD_STEP - MIN_THRESHOLD_STEP)
t = (float((threshold_value - MIN_THRESHOLD_STEP)) / float(threshold_range))
return PadParameters(curve_value, on_threshold=int((((1 - t) * MIN_ON_THRESHOLD) + (t * MAX_ON_THRESHOLD))), off_threshold=int((((1 - t) * MIN_OFF_THRESHOLD) + (t * MAX_OFF_THRESHOLD))))
| [
"def",
"make_pad_parameters",
"(",
"curve_value",
",",
"threshold_value",
")",
":",
"threshold_range",
"=",
"(",
"MAX_THRESHOLD_STEP",
"-",
"MIN_THRESHOLD_STEP",
")",
"t",
"=",
"(",
"float",
"(",
"(",
"threshold_value",
"-",
"MIN_THRESHOLD_STEP",
")",
")",
"/",
... | creates a valid padparameters object merging the sensitivity curve and threshold settings . | train | false |
5,804 | def run_only_if_redis_is_available(func):
try:
import redis
except ImportError:
redis = None
pred = (lambda : (redis is not None))
return run_only(func, pred)
| [
"def",
"run_only_if_redis_is_available",
"(",
"func",
")",
":",
"try",
":",
"import",
"redis",
"except",
"ImportError",
":",
"redis",
"=",
"None",
"pred",
"=",
"(",
"lambda",
":",
"(",
"redis",
"is",
"not",
"None",
")",
")",
"return",
"run_only",
"(",
"f... | decorator for checking if python-redis is available . | train | false |
5,805 | def scan_update(item):
path = str(item.path())
try:
(title, desc, svg) = preview_parse(path)
except SAXParseException as ex:
log.error('%r is malformed (%r)', path, ex)
item.setEnabled(False)
item.setSelectable(False)
return
if (not svg):
try:
svg = scheme_svg_thumbnail(path)
except Exception:
log.error('Could not render scheme preview for %r', title, exc_info=True)
if (item.name() != title):
item.setName(title)
if (item.description() != desc):
item.setDescription(desc)
if svg:
item.setThumbnail(svg)
| [
"def",
"scan_update",
"(",
"item",
")",
":",
"path",
"=",
"str",
"(",
"item",
".",
"path",
"(",
")",
")",
"try",
":",
"(",
"title",
",",
"desc",
",",
"svg",
")",
"=",
"preview_parse",
"(",
"path",
")",
"except",
"SAXParseException",
"as",
"ex",
":"... | given a preview item . | train | false |
5,807 | def test_escaped_task_arg_split():
argstr = 'foo,bar\\,biz\\,baz,what comes after baz?'
eq_(_escape_split(',', argstr), ['foo', 'bar,biz,baz', 'what comes after baz?'])
| [
"def",
"test_escaped_task_arg_split",
"(",
")",
":",
"argstr",
"=",
"'foo,bar\\\\,biz\\\\,baz,what comes after baz?'",
"eq_",
"(",
"_escape_split",
"(",
"','",
",",
"argstr",
")",
",",
"[",
"'foo'",
",",
"'bar,biz,baz'",
",",
"'what comes after baz?'",
"]",
")"
] | allow backslashes to escape the task argument separator character . | train | false |
5,809 | def DumpClientYaml(client_urn, target_dir, token=None, overwrite=False):
fd = aff4.FACTORY.Open(client_urn, aff4_grr.VFSGRRClient, token=token)
dirpath = os.path.join(target_dir, fd.urn.Split()[0])
try:
os.makedirs(dirpath)
except OSError:
pass
filepath = os.path.join(dirpath, 'client_info.yaml')
if ((not os.path.isfile(filepath)) or overwrite):
with open(filepath, 'wb') as out_file:
out_file.write(serialize.YamlDumper(fd))
| [
"def",
"DumpClientYaml",
"(",
"client_urn",
",",
"target_dir",
",",
"token",
"=",
"None",
",",
"overwrite",
"=",
"False",
")",
":",
"fd",
"=",
"aff4",
".",
"FACTORY",
".",
"Open",
"(",
"client_urn",
",",
"aff4_grr",
".",
"VFSGRRClient",
",",
"token",
"="... | dump a yaml file containing client info . | train | true |
5,811 | def splitdrive(p):
return ('', p)
| [
"def",
"splitdrive",
"(",
"p",
")",
":",
"return",
"(",
"''",
",",
"p",
")"
] | split a pathname into drive/unc sharepoint and relative path specifiers . | train | false |
5,812 | def _engine_builder(con):
global _SQLALCHEMY_INSTALLED
if isinstance(con, string_types):
try:
import sqlalchemy
except ImportError:
_SQLALCHEMY_INSTALLED = False
else:
con = sqlalchemy.create_engine(con)
return con
return con
| [
"def",
"_engine_builder",
"(",
"con",
")",
":",
"global",
"_SQLALCHEMY_INSTALLED",
"if",
"isinstance",
"(",
"con",
",",
"string_types",
")",
":",
"try",
":",
"import",
"sqlalchemy",
"except",
"ImportError",
":",
"_SQLALCHEMY_INSTALLED",
"=",
"False",
"else",
":"... | returns a sqlalchemy engine from a uri else it just return con without modifying it . | train | true |
5,813 | def create_merge_tree(func, keys, token):
level = 0
prev_width = len(keys)
prev_keys = iter(keys)
rv = {}
while (prev_width > 1):
width = tree_width(prev_width)
groups = tree_groups(prev_width, width)
keys = [(token, level, i) for i in range(width)]
rv.update(((key, (func, list(take(num, prev_keys)))) for (num, key) in zip(groups, keys)))
prev_width = width
prev_keys = iter(keys)
level += 1
return rv
| [
"def",
"create_merge_tree",
"(",
"func",
",",
"keys",
",",
"token",
")",
":",
"level",
"=",
"0",
"prev_width",
"=",
"len",
"(",
"keys",
")",
"prev_keys",
"=",
"iter",
"(",
"keys",
")",
"rv",
"=",
"{",
"}",
"while",
"(",
"prev_width",
">",
"1",
")",... | create a task tree that merges all the keys with a reduction function . | train | false |
5,814 | def set_servers(*servers):
service_name = 'w32time'
if (not __salt__['service.status'](service_name)):
if (not __salt__['service.start'](service_name)):
return False
server_cmd = ['W32tm', '/config', '/syncfromflags:manual', '/manualpeerlist:{0}'.format(' '.join(servers))]
reliable_cmd = ['W32tm', '/config', '/reliable:yes']
update_cmd = ['W32tm', '/config', '/update']
for cmd in (server_cmd, reliable_cmd, update_cmd):
ret = __salt__['cmd.run'](cmd, python_shell=False)
if ('command completed successfully' not in ret):
return False
__salt__['service.restart'](service_name)
return True
| [
"def",
"set_servers",
"(",
"*",
"servers",
")",
":",
"service_name",
"=",
"'w32time'",
"if",
"(",
"not",
"__salt__",
"[",
"'service.status'",
"]",
"(",
"service_name",
")",
")",
":",
"if",
"(",
"not",
"__salt__",
"[",
"'service.start'",
"]",
"(",
"service_... | configures a list of ntp servers on the device . | train | false |
5,815 | def get_config(config_file, repo, ctx, dir):
config_file = basic_util.strip_path(config_file)
for changeset in reversed_upper_bounded_changelog(repo, ctx):
changeset_ctx = repo.changectx(changeset)
for ctx_file in changeset_ctx.files():
ctx_file_name = basic_util.strip_path(ctx_file)
if (ctx_file_name == config_file):
return get_named_tmpfile_from_ctx(changeset_ctx, ctx_file, dir)
return None
| [
"def",
"get_config",
"(",
"config_file",
",",
"repo",
",",
"ctx",
",",
"dir",
")",
":",
"config_file",
"=",
"basic_util",
".",
"strip_path",
"(",
"config_file",
")",
"for",
"changeset",
"in",
"reversed_upper_bounded_changelog",
"(",
"repo",
",",
"ctx",
")",
... | load configuration from ini . | train | false |
5,817 | def get_student_from_identifier(unique_student_identifier):
unique_student_identifier = strip_if_string(unique_student_identifier)
if ('@' in unique_student_identifier):
student = User.objects.get(email=unique_student_identifier)
else:
student = User.objects.get(username=unique_student_identifier)
return student
| [
"def",
"get_student_from_identifier",
"(",
"unique_student_identifier",
")",
":",
"unique_student_identifier",
"=",
"strip_if_string",
"(",
"unique_student_identifier",
")",
"if",
"(",
"'@'",
"in",
"unique_student_identifier",
")",
":",
"student",
"=",
"User",
".",
"obj... | gets a student object using either an email address or username . | train | false |
5,818 | def Rep(re):
result = Opt(Rep1(re))
result.str = ('Rep(%s)' % re)
return result
| [
"def",
"Rep",
"(",
"re",
")",
":",
"result",
"=",
"Opt",
"(",
"Rep1",
"(",
"re",
")",
")",
"result",
".",
"str",
"=",
"(",
"'Rep(%s)'",
"%",
"re",
")",
"return",
"result"
] | rep is an re which matches zero or more repetitions of |re| . | train | false |
5,819 | def get_message_date(content, header='Date'):
message = MailParser().parsestr(content, True)
dateheader = message.get(header)
datetuple = email.utils.parsedate_tz(dateheader)
if (datetuple is None):
return None
return email.utils.mktime_tz(datetuple)
| [
"def",
"get_message_date",
"(",
"content",
",",
"header",
"=",
"'Date'",
")",
":",
"message",
"=",
"MailParser",
"(",
")",
".",
"parsestr",
"(",
"content",
",",
"True",
")",
"dateheader",
"=",
"message",
".",
"get",
"(",
"header",
")",
"datetuple",
"=",
... | parses mail and returns resulting timestamp . | train | false |
5,820 | @as_op(itypes=[tt.lscalar, tt.dscalar, tt.dscalar], otypes=[tt.dvector])
def rateFunc(switchpoint, early_mean, late_mean):
out = empty(years)
out[:switchpoint] = early_mean
out[switchpoint:] = late_mean
return out
| [
"@",
"as_op",
"(",
"itypes",
"=",
"[",
"tt",
".",
"lscalar",
",",
"tt",
".",
"dscalar",
",",
"tt",
".",
"dscalar",
"]",
",",
"otypes",
"=",
"[",
"tt",
".",
"dvector",
"]",
")",
"def",
"rateFunc",
"(",
"switchpoint",
",",
"early_mean",
",",
"late_me... | concatenate poisson means . | train | false |
5,821 | def find_contours(array, level, fully_connected='low', positive_orientation='low'):
array = np.asarray(array, dtype=np.double)
if (array.ndim != 2):
raise ValueError('Only 2D arrays are supported.')
level = float(level)
if ((fully_connected not in _param_options) or (positive_orientation not in _param_options)):
raise ValueError('Parameters "fully_connected" and "positive_orientation" must be either "high" or "low".')
point_list = _find_contours_cy.iterate_and_store(array, level, (fully_connected == 'high'))
contours = _assemble_contours(_take_2(point_list))
if (positive_orientation == 'high'):
contours = [c[::(-1)] for c in contours]
return contours
| [
"def",
"find_contours",
"(",
"array",
",",
"level",
",",
"fully_connected",
"=",
"'low'",
",",
"positive_orientation",
"=",
"'low'",
")",
":",
"array",
"=",
"np",
".",
"asarray",
"(",
"array",
",",
"dtype",
"=",
"np",
".",
"double",
")",
"if",
"(",
"ar... | find iso-valued contours in a 2d array for a given level value . | train | true |
5,823 | def publish_cmdline_to_binary(reader=None, reader_name='standalone', parser=None, parser_name='restructuredtext', writer=None, writer_name='pseudoxml', settings=None, settings_spec=None, settings_overrides=None, config_section=None, enable_exit_status=True, argv=None, usage=default_usage, description=default_description, destination=None, destination_class=io.BinaryFileOutput):
pub = Publisher(reader, parser, writer, settings=settings, destination_class=destination_class)
pub.set_components(reader_name, parser_name, writer_name)
output = pub.publish(argv, usage, description, settings_spec, settings_overrides, config_section=config_section, enable_exit_status=enable_exit_status)
return output
| [
"def",
"publish_cmdline_to_binary",
"(",
"reader",
"=",
"None",
",",
"reader_name",
"=",
"'standalone'",
",",
"parser",
"=",
"None",
",",
"parser_name",
"=",
"'restructuredtext'",
",",
"writer",
"=",
"None",
",",
"writer_name",
"=",
"'pseudoxml'",
",",
"settings... | set up & run a publisher for command-line-based file i/o . | train | false |
5,824 | def getTokenEnd(characterIndex, fileText, token):
tokenIndex = fileText.find(token, characterIndex)
if (tokenIndex == (-1)):
return (-1)
return (tokenIndex + len(token))
| [
"def",
"getTokenEnd",
"(",
"characterIndex",
",",
"fileText",
",",
"token",
")",
":",
"tokenIndex",
"=",
"fileText",
".",
"find",
"(",
"token",
",",
"characterIndex",
")",
"if",
"(",
"tokenIndex",
"==",
"(",
"-",
"1",
")",
")",
":",
"return",
"(",
"-",... | get the token end index for the file text and token . | train | false |
5,825 | def strip_filenames(descriptor):
print 'strip filename from {desc}'.format(desc=descriptor.location.to_deprecated_string())
if descriptor._field_data.has(descriptor, 'filename'):
descriptor._field_data.delete(descriptor, 'filename')
if hasattr(descriptor, 'xml_attributes'):
if ('filename' in descriptor.xml_attributes):
del descriptor.xml_attributes['filename']
for child in descriptor.get_children():
strip_filenames(child)
descriptor.save()
| [
"def",
"strip_filenames",
"(",
"descriptor",
")",
":",
"print",
"'strip filename from {desc}'",
".",
"format",
"(",
"desc",
"=",
"descriptor",
".",
"location",
".",
"to_deprecated_string",
"(",
")",
")",
"if",
"descriptor",
".",
"_field_data",
".",
"has",
"(",
... | recursively strips filename from all childrens definitions . | train | false |
5,827 | def cert_base_path(cacert_path=None):
if (not cacert_path):
cacert_path = __context__.get('ca.contextual_cert_base_path', __salt__['config.option']('ca.contextual_cert_base_path'))
if (not cacert_path):
cacert_path = __context__.get('ca.cert_base_path', __salt__['config.option']('ca.cert_base_path'))
return cacert_path
| [
"def",
"cert_base_path",
"(",
"cacert_path",
"=",
"None",
")",
":",
"if",
"(",
"not",
"cacert_path",
")",
":",
"cacert_path",
"=",
"__context__",
".",
"get",
"(",
"'ca.contextual_cert_base_path'",
",",
"__salt__",
"[",
"'config.option'",
"]",
"(",
"'ca.contextua... | return the base path for certs from cli or from options cacert_path absolute path to ca certificates root directory cli example: . | train | true |
5,828 | def get_expected_validation_developer_message(preference_key, preference_value):
return u"Value '{preference_value}' not valid for preference '{preference_key}': {error}".format(preference_key=preference_key, preference_value=preference_value, error={'key': [u'Ensure this value has at most 255 characters (it has 256).']})
| [
"def",
"get_expected_validation_developer_message",
"(",
"preference_key",
",",
"preference_value",
")",
":",
"return",
"u\"Value '{preference_value}' not valid for preference '{preference_key}': {error}\"",
".",
"format",
"(",
"preference_key",
"=",
"preference_key",
",",
"prefere... | returns the expected dict of validation messages for the specified key . | train | false |
5,829 | def raisingResolverFactory(*args, **kwargs):
raise ResolverFactoryArguments(args, kwargs)
| [
"def",
"raisingResolverFactory",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"raise",
"ResolverFactoryArguments",
"(",
"args",
",",
"kwargs",
")"
] | raise a l{resolverfactoryarguments} exception containing the positional and keyword arguments passed to resolverfactory . | train | false |
5,831 | def handle_ctrl_c():
oldhook = sys.excepthook
def newhook(exctype, value, traceback):
if (exctype == KeyboardInterrupt):
log('\nInterrupted.\n')
else:
return oldhook(exctype, value, traceback)
sys.excepthook = newhook
| [
"def",
"handle_ctrl_c",
"(",
")",
":",
"oldhook",
"=",
"sys",
".",
"excepthook",
"def",
"newhook",
"(",
"exctype",
",",
"value",
",",
"traceback",
")",
":",
"if",
"(",
"exctype",
"==",
"KeyboardInterrupt",
")",
":",
"log",
"(",
"'\\nInterrupted.\\n'",
")",... | replace the default exception handler for keyboardinterrupt . | train | false |
5,833 | def kruskal_MST(gr):
sorted_edges = sorted(gr.get_edge_weights())
uf = UnionFind()
min_cost = 0
for (w, (u, v)) in sorted_edges:
if (((not uf.get_leader(u)) and (not uf.get_leader(v))) or (uf.get_leader(u) != uf.get_leader(v))):
uf.insert(u, v)
min_cost += w
return min_cost
| [
"def",
"kruskal_MST",
"(",
"gr",
")",
":",
"sorted_edges",
"=",
"sorted",
"(",
"gr",
".",
"get_edge_weights",
"(",
")",
")",
"uf",
"=",
"UnionFind",
"(",
")",
"min_cost",
"=",
"0",
"for",
"(",
"w",
",",
"(",
"u",
",",
"v",
")",
")",
"in",
"sorted... | computes minimum cost spanning tree in a undirected . | train | false |
5,836 | def activateAaPdpContextReject(ProtocolConfigurationOptions_presence=0):
a = TpPd(pd=8)
b = MessageType(mesType=82)
c = SmCause()
packet = ((a / b) / c)
if (ProtocolConfigurationOptions_presence is 1):
d = ProtocolConfigurationOptions(ieiPCO=39)
packet = (packet / d)
return packet
| [
"def",
"activateAaPdpContextReject",
"(",
"ProtocolConfigurationOptions_presence",
"=",
"0",
")",
":",
"a",
"=",
"TpPd",
"(",
"pd",
"=",
"8",
")",
"b",
"=",
"MessageType",
"(",
"mesType",
"=",
"82",
")",
"c",
"=",
"SmCause",
"(",
")",
"packet",
"=",
"(",... | activate aa pdp context reject section 9 . | train | true |
5,837 | def makeKW(rowClass, args):
kw = {}
for i in range(0, len(args)):
columnName = rowClass.dbColumns[i][0].lower()
for attr in rowClass.rowColumns:
if (attr.lower() == columnName):
kw[attr] = args[i]
break
return kw
| [
"def",
"makeKW",
"(",
"rowClass",
",",
"args",
")",
":",
"kw",
"=",
"{",
"}",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"len",
"(",
"args",
")",
")",
":",
"columnName",
"=",
"rowClass",
".",
"dbColumns",
"[",
"i",
"]",
"[",
"0",
"]",
".",
"lo... | utility method to construct a dictionary for the attributes of an object from set of args . | train | false |
5,838 | def save_file_dialog(default_format='png'):
filename = QtGui.QFileDialog.getSaveFileName()
filename = _format_filename(filename)
if (filename is None):
return None
(basename, ext) = os.path.splitext(filename)
if (not ext):
filename = ('%s.%s' % (filename, default_format))
return filename
| [
"def",
"save_file_dialog",
"(",
"default_format",
"=",
"'png'",
")",
":",
"filename",
"=",
"QtGui",
".",
"QFileDialog",
".",
"getSaveFileName",
"(",
")",
"filename",
"=",
"_format_filename",
"(",
"filename",
")",
"if",
"(",
"filename",
"is",
"None",
")",
":"... | return user-selected file path . | train | false |
5,840 | def find_device(ec2, module, device_id, isinstance=True):
if isinstance:
try:
reservations = ec2.get_all_reservations(instance_ids=[device_id])
except boto.exception.EC2ResponseError as e:
module.fail_json(msg=str(e))
if (len(reservations) == 1):
instances = reservations[0].instances
if (len(instances) == 1):
return instances[0]
else:
try:
interfaces = ec2.get_all_network_interfaces(network_interface_ids=[device_id])
except boto.exception.EC2ResponseError as e:
module.fail_json(msg=str(e))
if (len(interfaces) == 1):
return interfaces[0]
raise EIPException(('could not find instance' + device_id))
| [
"def",
"find_device",
"(",
"ec2",
",",
"module",
",",
"device_id",
",",
"isinstance",
"=",
"True",
")",
":",
"if",
"isinstance",
":",
"try",
":",
"reservations",
"=",
"ec2",
".",
"get_all_reservations",
"(",
"instance_ids",
"=",
"[",
"device_id",
"]",
")",... | find a device in zenoss . | train | false |
5,841 | def _check_cmd(call):
if (call['retcode'] != 0):
comment = ''
std_err = call.get('stderr')
std_out = call.get('stdout')
if std_err:
comment += std_err
if std_out:
comment += std_out
raise CommandExecutionError('Error running command: {0}'.format(comment))
return call
| [
"def",
"_check_cmd",
"(",
"call",
")",
":",
"if",
"(",
"call",
"[",
"'retcode'",
"]",
"!=",
"0",
")",
":",
"comment",
"=",
"''",
"std_err",
"=",
"call",
".",
"get",
"(",
"'stderr'",
")",
"std_out",
"=",
"call",
".",
"get",
"(",
"'stdout'",
")",
"... | check the output of the cmd . | train | true |
5,844 | def salt():
letters = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/.'
return '$6${0}'.format(''.join([random.choice(letters) for i in range(16)]))
| [
"def",
"salt",
"(",
")",
":",
"letters",
"=",
"'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789/.'",
"return",
"'$6${0}'",
".",
"format",
"(",
"''",
".",
"join",
"(",
"[",
"random",
".",
"choice",
"(",
"letters",
")",
"for",
"i",
"in",
"range",
... | returns a string of 2 random letters . | train | false |
5,845 | def is_rarfile(xfile):
rar_ver = _get_rar_version(xfile)
if rar_ver:
return ('RAR%d' % rar_ver)
else:
return None
| [
"def",
"is_rarfile",
"(",
"xfile",
")",
":",
"rar_ver",
"=",
"_get_rar_version",
"(",
"xfile",
")",
"if",
"rar_ver",
":",
"return",
"(",
"'RAR%d'",
"%",
"rar_ver",
")",
"else",
":",
"return",
"None"
] | check quickly whether file is rar archive . | train | false |
5,846 | @testing.requires_testing_data
def test_edf_reduced():
_test_raw_reader(read_raw_edf, input_fname=edf_reduced, stim_channel=None)
| [
"@",
"testing",
".",
"requires_testing_data",
"def",
"test_edf_reduced",
"(",
")",
":",
"_test_raw_reader",
"(",
"read_raw_edf",
",",
"input_fname",
"=",
"edf_reduced",
",",
"stim_channel",
"=",
"None",
")"
] | test edf with various sampling rates . | train | false |
5,847 | def enable_nat(interface):
run(settings.iptables, '-t', 'nat', '-A', 'POSTROUTING', '-o', interface, '-j', 'MASQUERADE')
| [
"def",
"enable_nat",
"(",
"interface",
")",
":",
"run",
"(",
"settings",
".",
"iptables",
",",
"'-t'",
",",
"'nat'",
",",
"'-A'",
",",
"'POSTROUTING'",
",",
"'-o'",
",",
"interface",
",",
"'-j'",
",",
"'MASQUERADE'",
")"
] | enable nat on this interface . | train | false |
5,848 | def get_official_service_name(service_model):
official_name = service_model.metadata.get('serviceFullName')
short_name = service_model.metadata.get('serviceAbbreviation', '')
if short_name.startswith('Amazon'):
short_name = short_name[7:]
if short_name.startswith('AWS'):
short_name = short_name[4:]
if (short_name and (short_name.lower() not in official_name.lower())):
official_name += ' ({0})'.format(short_name)
return official_name
| [
"def",
"get_official_service_name",
"(",
"service_model",
")",
":",
"official_name",
"=",
"service_model",
".",
"metadata",
".",
"get",
"(",
"'serviceFullName'",
")",
"short_name",
"=",
"service_model",
".",
"metadata",
".",
"get",
"(",
"'serviceAbbreviation'",
",",... | generate the official name of an aws service . | train | false |
5,849 | def MessageSizer(field_number, is_repeated, is_packed):
tag_size = _TagSize(field_number)
local_VarintSize = _VarintSize
assert (not is_packed)
if is_repeated:
def RepeatedFieldSize(value):
result = (tag_size * len(value))
for element in value:
l = element.ByteSize()
result += (local_VarintSize(l) + l)
return result
return RepeatedFieldSize
else:
def FieldSize(value):
l = value.ByteSize()
return ((tag_size + local_VarintSize(l)) + l)
return FieldSize
| [
"def",
"MessageSizer",
"(",
"field_number",
",",
"is_repeated",
",",
"is_packed",
")",
":",
"tag_size",
"=",
"_TagSize",
"(",
"field_number",
")",
"local_VarintSize",
"=",
"_VarintSize",
"assert",
"(",
"not",
"is_packed",
")",
"if",
"is_repeated",
":",
"def",
... | returns a sizer for a message field . | train | true |
5,851 | def all_permissions_for_user_in_course(user, course_id):
course = modulestore().get_course(course_id)
if (course is None):
raise ItemNotFoundError(course_id)
all_roles = {role.name for role in Role.objects.filter(users=user, course_id=course_id)}
permissions = {permission.name for permission in Permission.objects.filter(roles__users=user, roles__course_id=course_id) if (not permission_blacked_out(course, all_roles, permission.name))}
return permissions
| [
"def",
"all_permissions_for_user_in_course",
"(",
"user",
",",
"course_id",
")",
":",
"course",
"=",
"modulestore",
"(",
")",
".",
"get_course",
"(",
"course_id",
")",
"if",
"(",
"course",
"is",
"None",
")",
":",
"raise",
"ItemNotFoundError",
"(",
"course_id",... | returns all the permissions the user has in the given course . | train | false |
5,852 | def _morph_mult(data, e, use_sparse, idx_use_data, idx_use_out=None):
if (len(idx_use_data) < e.shape[1]):
if use_sparse:
data = (e[:, idx_use_data] * data)
else:
(col, row) = np.meshgrid(np.arange(data.shape[1]), idx_use_data)
d_sparse = sparse.csr_matrix((data.ravel(), (row.ravel(), col.ravel())), shape=(e.shape[1], data.shape[1]))
data = (e * d_sparse)
data = np.asarray(data.todense())
else:
data = (e * data)
if (idx_use_out is not None):
data = data[idx_use_out]
return data
| [
"def",
"_morph_mult",
"(",
"data",
",",
"e",
",",
"use_sparse",
",",
"idx_use_data",
",",
"idx_use_out",
"=",
"None",
")",
":",
"if",
"(",
"len",
"(",
"idx_use_data",
")",
"<",
"e",
".",
"shape",
"[",
"1",
"]",
")",
":",
"if",
"use_sparse",
":",
"d... | helper for morphing . | train | false |
5,853 | def services_for_instance(instance_id):
ec2 = boto.ec2.connect_to_region(REGION)
reservations = ec2.get_all_instances(instance_ids=[instance_id])
for reservation in reservations:
for instance in reservation.instances:
if (instance.id == instance_id):
try:
services = instance.tags['services'].split(',')
except KeyError as ke:
msg = "Tag named 'services' not found on this instance({})".format(instance_id)
raise Exception(msg)
for service in services:
(yield service)
| [
"def",
"services_for_instance",
"(",
"instance_id",
")",
":",
"ec2",
"=",
"boto",
".",
"ec2",
".",
"connect_to_region",
"(",
"REGION",
")",
"reservations",
"=",
"ec2",
".",
"get_all_instances",
"(",
"instance_ids",
"=",
"[",
"instance_id",
"]",
")",
"for",
"... | get the list of all services named by the services tag in this instances tags . | train | false |
5,854 | def sanitize_and_trim_path(path):
path = path.strip()
new_path = ''
if sabnzbd.WIN32:
if path.startswith(u'\\\\?\\UNC\\'):
new_path = u'\\\\?\\UNC\\'
path = path[8:]
elif path.startswith(u'\\\\?\\'):
new_path = u'\\\\?\\'
path = path[4:]
path = path.replace('\\', '/')
parts = path.split('/')
if (sabnzbd.WIN32 and (len(parts[0]) == 2) and (':' in parts[0])):
new_path += (parts[0] + '/')
parts.pop(0)
elif path.startswith('//'):
new_path = '//'
elif path.startswith('/'):
new_path = '/'
for part in parts:
new_path = os.path.join(new_path, sanitize_foldername(part))
return os.path.abspath(os.path.normpath(new_path))
| [
"def",
"sanitize_and_trim_path",
"(",
"path",
")",
":",
"path",
"=",
"path",
".",
"strip",
"(",
")",
"new_path",
"=",
"''",
"if",
"sabnzbd",
".",
"WIN32",
":",
"if",
"path",
".",
"startswith",
"(",
"u'\\\\\\\\?\\\\UNC\\\\'",
")",
":",
"new_path",
"=",
"u... | remove illegal characters and trim element size . | train | false |
5,855 | def early_stopping_monitor(i, est, locals):
if (i == 9):
return True
else:
return False
| [
"def",
"early_stopping_monitor",
"(",
"i",
",",
"est",
",",
"locals",
")",
":",
"if",
"(",
"i",
"==",
"9",
")",
":",
"return",
"True",
"else",
":",
"return",
"False"
] | returns true on the 10th iteration . | train | false |
5,856 | def sort_versions(version_list):
versions = []
for version_obj in version_list:
version_slug = version_obj.verbose_name
comparable_version = parse_version_failsafe(version_slug)
if comparable_version:
versions.append((version_obj, comparable_version))
return list(sorted(versions, key=(lambda version_info: version_info[1]), reverse=True))
| [
"def",
"sort_versions",
"(",
"version_list",
")",
":",
"versions",
"=",
"[",
"]",
"for",
"version_obj",
"in",
"version_list",
":",
"version_slug",
"=",
"version_obj",
".",
"verbose_name",
"comparable_version",
"=",
"parse_version_failsafe",
"(",
"version_slug",
")",... | takes a list of version models and return a sorted list . | train | false |
5,857 | def _update_exif_orientation(exif, orientation):
exif_dict = piexif.load(exif)
if orientation:
exif_dict['0th'][piexif.ImageIFD.Orientation] = orientation
return piexif.dump(exif_dict)
| [
"def",
"_update_exif_orientation",
"(",
"exif",
",",
"orientation",
")",
":",
"exif_dict",
"=",
"piexif",
".",
"load",
"(",
"exif",
")",
"if",
"orientation",
":",
"exif_dict",
"[",
"'0th'",
"]",
"[",
"piexif",
".",
"ImageIFD",
".",
"Orientation",
"]",
"=",... | given an exif value and an integer value 1-8 . | train | false |
5,858 | def test_too_many_cols1():
text = '\nA B C\n1 2 3\n4 5 6\n7 8 9 10\n11 12 13\n'
with pytest.raises(CParserError) as e:
table = FastBasic().read(text)
assert ('CParserError: an error occurred while parsing table data: too many columns found in line 3 of data' in str(e))
| [
"def",
"test_too_many_cols1",
"(",
")",
":",
"text",
"=",
"'\\nA B C\\n1 2 3\\n4 5 6\\n7 8 9 10\\n11 12 13\\n'",
"with",
"pytest",
".",
"raises",
"(",
"CParserError",
")",
"as",
"e",
":",
"table",
"=",
"FastBasic",
"(",
")",
".",
"read",
"(",
"text",
")",
"ass... | if a row contains too many columns . | train | false |
5,860 | def generate_subs(speed, source_speed, source_subs):
if (speed == source_speed):
return source_subs
coefficient = ((1.0 * speed) / source_speed)
subs = {'start': [int(round((timestamp * coefficient))) for timestamp in source_subs['start']], 'end': [int(round((timestamp * coefficient))) for timestamp in source_subs['end']], 'text': source_subs['text']}
return subs
| [
"def",
"generate_subs",
"(",
"speed",
",",
"source_speed",
",",
"source_subs",
")",
":",
"if",
"(",
"speed",
"==",
"source_speed",
")",
":",
"return",
"source_subs",
"coefficient",
"=",
"(",
"(",
"1.0",
"*",
"speed",
")",
"/",
"source_speed",
")",
"subs",
... | generate transcripts from one speed to another speed . | train | false |
5,861 | def property_clean(prop, value):
if (value is not None):
try:
prop.validate(prop.make_value_from_form(value))
except (db.BadValueError, ValueError) as e:
raise forms.ValidationError(unicode(e))
| [
"def",
"property_clean",
"(",
"prop",
",",
"value",
")",
":",
"if",
"(",
"value",
"is",
"not",
"None",
")",
":",
"try",
":",
"prop",
".",
"validate",
"(",
"prop",
".",
"make_value_from_form",
"(",
"value",
")",
")",
"except",
"(",
"db",
".",
"BadValu... | apply property level validation to value . | train | false |
5,862 | def verifyReturnTo(realm_str, return_to, _vrfy=getAllowedReturnURLs):
realm = TrustRoot.parse(realm_str)
if (realm is None):
return False
try:
allowable_urls = _vrfy(realm.buildDiscoveryURL())
except RealmVerificationRedirected as err:
oidutil.log(str(err))
return False
if returnToMatches(allowable_urls, return_to):
return True
else:
oidutil.log(('Failed to validate return_to %r for realm %r, was not in %s' % (return_to, realm_str, allowable_urls)))
return False
| [
"def",
"verifyReturnTo",
"(",
"realm_str",
",",
"return_to",
",",
"_vrfy",
"=",
"getAllowedReturnURLs",
")",
":",
"realm",
"=",
"TrustRoot",
".",
"parse",
"(",
"realm_str",
")",
"if",
"(",
"realm",
"is",
"None",
")",
":",
"return",
"False",
"try",
":",
"... | verify that a return_to url is valid for the given realm . | train | false |
5,864 | def get_most_recent_messages(exp_id):
thread_models = feedback_models.FeedbackThreadModel.get_threads(exp_id, limit=feconf.OPEN_FEEDBACK_COUNT_DASHBOARD)
message_models = []
for thread_model in thread_models:
message_models.append(feedback_models.FeedbackMessageModel.get_most_recent_message(exp_id, thread_model.thread_id))
return [_get_message_from_model(message_model) for message_model in message_models]
| [
"def",
"get_most_recent_messages",
"(",
"exp_id",
")",
":",
"thread_models",
"=",
"feedback_models",
".",
"FeedbackThreadModel",
".",
"get_threads",
"(",
"exp_id",
",",
"limit",
"=",
"feconf",
".",
"OPEN_FEEDBACK_COUNT_DASHBOARD",
")",
"message_models",
"=",
"[",
"]... | fetch the most recently updated feedback threads for a given exploration . | train | false |
5,868 | def show_to_programming_language(promo, programming_language):
if promo.programming_language:
return (programming_language == promo.programming_language)
return True
| [
"def",
"show_to_programming_language",
"(",
"promo",
",",
"programming_language",
")",
":",
"if",
"promo",
".",
"programming_language",
":",
"return",
"(",
"programming_language",
"==",
"promo",
".",
"programming_language",
")",
"return",
"True"
] | filter a promo by a specific programming language return true if we havent set a specific language . | train | false |
5,870 | def ip_addrs(interface=None, include_loopback=False, interface_data=None):
return _ip_addrs(interface, include_loopback, interface_data, 'inet')
| [
"def",
"ip_addrs",
"(",
"interface",
"=",
"None",
",",
"include_loopback",
"=",
"False",
",",
"interface_data",
"=",
"None",
")",
":",
"return",
"_ip_addrs",
"(",
"interface",
",",
"include_loopback",
",",
"interface_data",
",",
"'inet'",
")"
] | returns a list of ipv4 addresses assigned to the host . | train | false |
5,871 | def get_startup_disk():
ret = salt.utils.mac_utils.execute_return_result('systemsetup -getstartupdisk')
return salt.utils.mac_utils.parse_return(ret)
| [
"def",
"get_startup_disk",
"(",
")",
":",
"ret",
"=",
"salt",
".",
"utils",
".",
"mac_utils",
".",
"execute_return_result",
"(",
"'systemsetup -getstartupdisk'",
")",
"return",
"salt",
".",
"utils",
".",
"mac_utils",
".",
"parse_return",
"(",
"ret",
")"
] | displays the current startup disk :return: the current startup disk :rtype: str cli example: . | train | false |
5,873 | def new(rsa_key):
return PKCS115_SigScheme(rsa_key)
| [
"def",
"new",
"(",
"rsa_key",
")",
":",
"return",
"PKCS115_SigScheme",
"(",
"rsa_key",
")"
] | create a new rc2 cipher . | train | false |
5,874 | def no_template_view(request):
return HttpResponse('No template used. Sample content: twice once twice. Content ends.')
| [
"def",
"no_template_view",
"(",
"request",
")",
":",
"return",
"HttpResponse",
"(",
"'No template used. Sample content: twice once twice. Content ends.'",
")"
] | a simple view that expects a get request . | train | false |
5,875 | @library.global_function
def profile_url(user, edit=False):
if edit:
return reverse('users.edit_profile', args=[user.username])
return reverse('users.profile', args=[user.username])
| [
"@",
"library",
".",
"global_function",
"def",
"profile_url",
"(",
"user",
",",
"edit",
"=",
"False",
")",
":",
"if",
"edit",
":",
"return",
"reverse",
"(",
"'users.edit_profile'",
",",
"args",
"=",
"[",
"user",
".",
"username",
"]",
")",
"return",
"reve... | return a url to the users profile . | train | false |
5,876 | def seed_milestone_relationship_types():
if (not settings.FEATURES.get('MILESTONES_APP')):
return None
MilestoneRelationshipType.objects.create(name='requires')
MilestoneRelationshipType.objects.create(name='fulfills')
| [
"def",
"seed_milestone_relationship_types",
"(",
")",
":",
"if",
"(",
"not",
"settings",
".",
"FEATURES",
".",
"get",
"(",
"'MILESTONES_APP'",
")",
")",
":",
"return",
"None",
"MilestoneRelationshipType",
".",
"objects",
".",
"create",
"(",
"name",
"=",
"'requ... | helper method to pre-populate mrts so the tests can run . | train | false |
5,878 | @removals.remove(message='keystoneclient auth plugins are deprecated. Use keystoneauth.', version='2.1.0', removal_version='3.0.0')
def get_common_conf_options():
return [_AUTH_PLUGIN_OPT, _AUTH_SECTION_OPT]
| [
"@",
"removals",
".",
"remove",
"(",
"message",
"=",
"'keystoneclient auth plugins are deprecated. Use keystoneauth.'",
",",
"version",
"=",
"'2.1.0'",
",",
"removal_version",
"=",
"'3.0.0'",
")",
"def",
"get_common_conf_options",
"(",
")",
":",
"return",
"[",
"_AUTH_... | get the oslo_config options common for all auth plugins . | train | false |
5,879 | @_FFI.callback(u'void(ExternContext*, Handle*, uint64_t)')
def extern_drop_handles(context_handle, handles_ptr, handles_len):
c = _FFI.from_handle(context_handle)
handles = _FFI.unpack(handles_ptr, handles_len)
c.drop_handles(handles)
| [
"@",
"_FFI",
".",
"callback",
"(",
"u'void(ExternContext*, Handle*, uint64_t)'",
")",
"def",
"extern_drop_handles",
"(",
"context_handle",
",",
"handles_ptr",
",",
"handles_len",
")",
":",
"c",
"=",
"_FFI",
".",
"from_handle",
"(",
"context_handle",
")",
"handles",
... | drop the given handles . | train | false |
5,881 | @celery_app.task(base=ArchiverTask, ignore_result=False)
@logged('archive_success')
def archive_success(dst_pk, job_pk):
create_app_context()
dst = Node.load(dst_pk)
for schema in dst.registered_schema.all():
if schema.has_files:
utils.migrate_file_metadata(dst, schema)
job = ArchiveJob.load(job_pk)
if (not job.sent):
job.sent = True
job.save()
dst.sanction.ask(dst.get_active_contributors_recursive(unique_users=True))
| [
"@",
"celery_app",
".",
"task",
"(",
"base",
"=",
"ArchiverTask",
",",
"ignore_result",
"=",
"False",
")",
"@",
"logged",
"(",
"'archive_success'",
")",
"def",
"archive_success",
"(",
"dst_pk",
",",
"job_pk",
")",
":",
"create_app_context",
"(",
")",
"dst",
... | archivers final callback . | train | false |
5,882 | def get_hot_factor(qdata, now, ageweight):
ageweight = float((ageweight or 0.0))
(link_name, hot, timestamp) = qdata
return max((hot + (((now - timestamp) * ageweight) / 45000.0)), 1.0)
| [
"def",
"get_hot_factor",
"(",
"qdata",
",",
"now",
",",
"ageweight",
")",
":",
"ageweight",
"=",
"float",
"(",
"(",
"ageweight",
"or",
"0.0",
")",
")",
"(",
"link_name",
",",
"hot",
",",
"timestamp",
")",
"=",
"qdata",
"return",
"max",
"(",
"(",
"hot... | return a "hot factor" score for a links hot tuple . | train | false |
5,883 | def superposition_basis(nqubits):
amp = (1 / sqrt((2 ** nqubits)))
return sum([(amp * IntQubit(n, nqubits)) for n in range((2 ** nqubits))])
| [
"def",
"superposition_basis",
"(",
"nqubits",
")",
":",
"amp",
"=",
"(",
"1",
"/",
"sqrt",
"(",
"(",
"2",
"**",
"nqubits",
")",
")",
")",
"return",
"sum",
"(",
"[",
"(",
"amp",
"*",
"IntQubit",
"(",
"n",
",",
"nqubits",
")",
")",
"for",
"n",
"i... | creates an equal superposition of the computational basis . | train | false |
5,884 | def itervalues(d):
return getattr(d, _itervalues)()
| [
"def",
"itervalues",
"(",
"d",
")",
":",
"return",
"getattr",
"(",
"d",
",",
"_itervalues",
")",
"(",
")"
] | return an iterator over the values of a dictionary . | train | false |
5,885 | def generate_table_alias(src_table_alias, joined_tables=[]):
alias = src_table_alias
if (not joined_tables):
return (('%s' % alias), ('%s' % _quote(alias)))
for link in joined_tables:
alias += ('__' + link[1])
if (len(alias) >= 64):
alias_hash = hex(crc32(alias))[2:]
ALIAS_PREFIX_LENGTH = ((63 - len(alias_hash)) - 1)
alias = ('%s_%s' % (alias[:ALIAS_PREFIX_LENGTH], alias_hash))
return (('%s' % alias), ('%s as %s' % (_quote(joined_tables[(-1)][0]), _quote(alias))))
| [
"def",
"generate_table_alias",
"(",
"src_table_alias",
",",
"joined_tables",
"=",
"[",
"]",
")",
":",
"alias",
"=",
"src_table_alias",
"if",
"(",
"not",
"joined_tables",
")",
":",
"return",
"(",
"(",
"'%s'",
"%",
"alias",
")",
",",
"(",
"'%s'",
"%",
"_qu... | generate a standard table alias name . | train | false |
5,886 | def BuildAdGroupOperations(batch_job_helper, campaign_operations, number_of_adgroups=1):
adgroup_operations = [{'xsi_type': 'AdGroupOperation', 'operand': {'campaignId': campaign_operation['operand']['id'], 'id': batch_job_helper.GetId(), 'name': ('Batch Ad Group #%s' % uuid.uuid4()), 'biddingStrategyConfiguration': {'bids': [{'xsi_type': 'CpcBid', 'bid': {'microAmount': 10000000}}]}}, 'operator': 'ADD'} for campaign_operation in campaign_operations for _ in range(number_of_adgroups)]
return adgroup_operations
| [
"def",
"BuildAdGroupOperations",
"(",
"batch_job_helper",
",",
"campaign_operations",
",",
"number_of_adgroups",
"=",
"1",
")",
":",
"adgroup_operations",
"=",
"[",
"{",
"'xsi_type'",
":",
"'AdGroupOperation'",
",",
"'operand'",
":",
"{",
"'campaignId'",
":",
"campa... | builds the operations adding desired number of adgroups to given campaigns . | train | true |
5,887 | def invalidate_country_rule_cache(sender, instance, **kwargs):
if isinstance(instance, RestrictedCourse):
RestrictedCourse.invalidate_cache_for_course(instance.course_key)
CountryAccessRule.invalidate_cache_for_course(instance.course_key)
if isinstance(instance, CountryAccessRule):
try:
restricted_course = instance.restricted_course
except RestrictedCourse.DoesNotExist:
pass
else:
CountryAccessRule.invalidate_cache_for_course(restricted_course.course_key)
| [
"def",
"invalidate_country_rule_cache",
"(",
"sender",
",",
"instance",
",",
"**",
"kwargs",
")",
":",
"if",
"isinstance",
"(",
"instance",
",",
"RestrictedCourse",
")",
":",
"RestrictedCourse",
".",
"invalidate_cache_for_course",
"(",
"instance",
".",
"course_key",... | invalidate cached rule information on changes to the rule models . | train | false |
5,888 | def looks_like_xml(text):
key = hash(text)
try:
return _looks_like_xml_cache[key]
except KeyError:
m = doctype_lookup_re.match(text)
if (m is not None):
return True
rv = (tag_re.search(text[:1000]) is not None)
_looks_like_xml_cache[key] = rv
return rv
| [
"def",
"looks_like_xml",
"(",
"text",
")",
":",
"key",
"=",
"hash",
"(",
"text",
")",
"try",
":",
"return",
"_looks_like_xml_cache",
"[",
"key",
"]",
"except",
"KeyError",
":",
"m",
"=",
"doctype_lookup_re",
".",
"match",
"(",
"text",
")",
"if",
"(",
"... | check if a doctype exists or if we have some tags . | train | true |
5,889 | @db_api.retry_if_session_inactive()
@db_api.context_manager.writer
def set_resources_quota_usage_dirty(context, resources, tenant_id, dirty=True):
query = db_utils.model_query(context, quota_models.QuotaUsage)
query = query.filter_by(tenant_id=tenant_id)
if resources:
query = query.filter(quota_models.QuotaUsage.resource.in_(resources))
return query.update({'dirty': dirty}, synchronize_session=False)
| [
"@",
"db_api",
".",
"retry_if_session_inactive",
"(",
")",
"@",
"db_api",
".",
"context_manager",
".",
"writer",
"def",
"set_resources_quota_usage_dirty",
"(",
"context",
",",
"resources",
",",
"tenant_id",
",",
"dirty",
"=",
"True",
")",
":",
"query",
"=",
"d... | set quota usage dirty bit for a given tenant and multiple resources . | train | false |
5,891 | def test_host_role_merge_deduping_off():
@roles('r1', 'r2')
@hosts('a')
def command():
pass
with settings(dedupe_hosts=False):
true_eq_hosts(command, ['a', 'a', 'b', 'b', 'c'], env={'roledefs': fake_roles})
| [
"def",
"test_host_role_merge_deduping_off",
"(",
")",
":",
"@",
"roles",
"(",
"'r1'",
",",
"'r2'",
")",
"@",
"hosts",
"(",
"'a'",
")",
"def",
"command",
"(",
")",
":",
"pass",
"with",
"settings",
"(",
"dedupe_hosts",
"=",
"False",
")",
":",
"true_eq_host... | allow turning deduping off . | train | false |
5,894 | def sub_tempita(s, context, file=None, name=None):
if (not s):
return None
if file:
context['__name'] = ('%s:%s' % (file, name))
elif name:
context['__name'] = name
from ..Tempita import sub
return sub(s, **context)
| [
"def",
"sub_tempita",
"(",
"s",
",",
"context",
",",
"file",
"=",
"None",
",",
"name",
"=",
"None",
")",
":",
"if",
"(",
"not",
"s",
")",
":",
"return",
"None",
"if",
"file",
":",
"context",
"[",
"'__name'",
"]",
"=",
"(",
"'%s:%s'",
"%",
"(",
... | run tempita on string s with given context . | train | false |
5,895 | def expanduser(path):
return path
| [
"def",
"expanduser",
"(",
"path",
")",
":",
"return",
"path"
] | expand ~ and ~user constructs . | train | false |
5,896 | def _key_from_query(query, qualifier=None):
stmt = query.with_labels().statement
compiled = stmt.compile()
params = compiled.params
return ' '.join(([str(compiled)] + [str(params[k]) for k in sorted(params)]))
| [
"def",
"_key_from_query",
"(",
"query",
",",
"qualifier",
"=",
"None",
")",
":",
"stmt",
"=",
"query",
".",
"with_labels",
"(",
")",
".",
"statement",
"compiled",
"=",
"stmt",
".",
"compile",
"(",
")",
"params",
"=",
"compiled",
".",
"params",
"return",
... | given a query . | train | false |
5,897 | def is_user_meta(server_type, key):
if (len(key) <= (8 + len(server_type))):
return False
return key.lower().startswith(get_user_meta_prefix(server_type))
| [
"def",
"is_user_meta",
"(",
"server_type",
",",
"key",
")",
":",
"if",
"(",
"len",
"(",
"key",
")",
"<=",
"(",
"8",
"+",
"len",
"(",
"server_type",
")",
")",
")",
":",
"return",
"False",
"return",
"key",
".",
"lower",
"(",
")",
".",
"startswith",
... | tests if a header key starts with and is longer than the user metadata prefix for given server type . | train | false |
5,899 | def decamel(s, separator='_'):
s = re.sub('([a-z0-9])([A-Z])', ('\\1%s\\2' % separator), s)
s = re.sub('([A-Z])([A-Z][a-z])', ('\\1%s\\2' % separator), s)
s = s.lower()
return s
| [
"def",
"decamel",
"(",
"s",
",",
"separator",
"=",
"'_'",
")",
":",
"s",
"=",
"re",
".",
"sub",
"(",
"'([a-z0-9])([A-Z])'",
",",
"(",
"'\\\\1%s\\\\2'",
"%",
"separator",
")",
",",
"s",
")",
"s",
"=",
"re",
".",
"sub",
"(",
"'([A-Z])([A-Z][a-z])'",
",... | returns the string with camelcase converted to underscores . | train | false |
5,900 | def register_extension(id, extension):
EXTENSION[extension.lower()] = id.upper()
| [
"def",
"register_extension",
"(",
"id",
",",
"extension",
")",
":",
"EXTENSION",
"[",
"extension",
".",
"lower",
"(",
")",
"]",
"=",
"id",
".",
"upper",
"(",
")"
] | registers an image extension . | train | false |
5,901 | def guard_fsys_type():
sabnzbd.encoding.change_fsys(cfg.fsys_type())
| [
"def",
"guard_fsys_type",
"(",
")",
":",
"sabnzbd",
".",
"encoding",
".",
"change_fsys",
"(",
"cfg",
".",
"fsys_type",
"(",
")",
")"
] | callback for change of file system naming type . | train | false |
5,902 | def _get_baseline_from_tag(config, tag):
last_snapshot = None
for snapshot in __salt__['snapper.list_snapshots'](config):
if (tag == snapshot['userdata'].get('baseline_tag')):
if ((not last_snapshot) or (last_snapshot['timestamp'] < snapshot['timestamp'])):
last_snapshot = snapshot
return last_snapshot
| [
"def",
"_get_baseline_from_tag",
"(",
"config",
",",
"tag",
")",
":",
"last_snapshot",
"=",
"None",
"for",
"snapshot",
"in",
"__salt__",
"[",
"'snapper.list_snapshots'",
"]",
"(",
"config",
")",
":",
"if",
"(",
"tag",
"==",
"snapshot",
"[",
"'userdata'",
"]"... | returns the last created baseline snapshot marked with tag . | train | true |
5,903 | def get_random_mac(api_handle, virt_type='xenpv'):
if virt_type.startswith('vmware'):
mac = [0, 80, 86, random.randint(0, 63), random.randint(0, 255), random.randint(0, 255)]
elif (virt_type.startswith('xen') or virt_type.startswith('qemu') or virt_type.startswith('kvm')):
mac = [0, 22, 62, random.randint(0, 127), random.randint(0, 255), random.randint(0, 255)]
else:
raise CX('virt mac assignment not yet supported')
mac = ':'.join(map((lambda x: ('%02x' % x)), mac))
systems = api_handle.systems()
while systems.find(mac_address=mac):
mac = get_random_mac(api_handle)
return mac
| [
"def",
"get_random_mac",
"(",
"api_handle",
",",
"virt_type",
"=",
"'xenpv'",
")",
":",
"if",
"virt_type",
".",
"startswith",
"(",
"'vmware'",
")",
":",
"mac",
"=",
"[",
"0",
",",
"80",
",",
"86",
",",
"random",
".",
"randint",
"(",
"0",
",",
"63",
... | generate a random mac address starting with fe:16:3e . | train | false |
5,904 | def _setup_browser_offsets(params, n_channels):
ylim = [((n_channels * 2) + 1), 0]
offset = (ylim[0] / n_channels)
params['offsets'] = ((np.arange(n_channels) * offset) + (offset / 2.0))
params['n_channels'] = n_channels
params['ax'].set_yticks(params['offsets'])
params['ax'].set_ylim(ylim)
params['vsel_patch'].set_height(n_channels)
line = params['ax_vertline']
line.set_data(line._x, np.array(params['ax'].get_ylim()))
| [
"def",
"_setup_browser_offsets",
"(",
"params",
",",
"n_channels",
")",
":",
"ylim",
"=",
"[",
"(",
"(",
"n_channels",
"*",
"2",
")",
"+",
"1",
")",
",",
"0",
"]",
"offset",
"=",
"(",
"ylim",
"[",
"0",
"]",
"/",
"n_channels",
")",
"params",
"[",
... | aux function for computing viewport height and adjusting offsets . | train | false |
5,905 | def validate_volume_type(volume_type):
if (volume_type not in VALID_VOLUME_TYPES):
raise ValueError(('Elasticsearch Domain VolumeType must be one of: %s' % ', '.join(VALID_VOLUME_TYPES)))
return volume_type
| [
"def",
"validate_volume_type",
"(",
"volume_type",
")",
":",
"if",
"(",
"volume_type",
"not",
"in",
"VALID_VOLUME_TYPES",
")",
":",
"raise",
"ValueError",
"(",
"(",
"'Elasticsearch Domain VolumeType must be one of: %s'",
"%",
"', '",
".",
"join",
"(",
"VALID_VOLUME_TY... | validate volumetype for elasticsearchdomain . | train | false |
5,906 | def make_sparse_uncorrelated(n_samples=100, n_features=10, random_state=None):
generator = check_random_state(random_state)
X = generator.normal(loc=0, scale=1, size=(n_samples, n_features))
y = generator.normal(loc=(((X[:, 0] + (2 * X[:, 1])) - (2 * X[:, 2])) - (1.5 * X[:, 3])), scale=np.ones(n_samples))
return (X, y)
| [
"def",
"make_sparse_uncorrelated",
"(",
"n_samples",
"=",
"100",
",",
"n_features",
"=",
"10",
",",
"random_state",
"=",
"None",
")",
":",
"generator",
"=",
"check_random_state",
"(",
"random_state",
")",
"X",
"=",
"generator",
".",
"normal",
"(",
"loc",
"="... | generate a random regression problem with sparse uncorrelated design this dataset is described in celeux et al [1] . | train | false |
5,908 | def getCarving(fileName):
pluginModule = fabmetheus_interpret.getInterpretPlugin(fileName)
if (pluginModule == None):
return None
return pluginModule.getCarving(fileName)
| [
"def",
"getCarving",
"(",
"fileName",
")",
":",
"pluginModule",
"=",
"fabmetheus_interpret",
".",
"getInterpretPlugin",
"(",
"fileName",
")",
"if",
"(",
"pluginModule",
"==",
"None",
")",
":",
"return",
"None",
"return",
"pluginModule",
".",
"getCarving",
"(",
... | get carving . | train | false |
5,909 | def get_urlconf(default=None):
thread = currentThread()
if (thread in _urlconfs):
return _urlconfs[thread]
return default
| [
"def",
"get_urlconf",
"(",
"default",
"=",
"None",
")",
":",
"thread",
"=",
"currentThread",
"(",
")",
"if",
"(",
"thread",
"in",
"_urlconfs",
")",
":",
"return",
"_urlconfs",
"[",
"thread",
"]",
"return",
"default"
] | return the root urlconf to use for the current thread if it has been changed from the default one . | train | false |
5,911 | def evaluate_pauli_product(arg):
start = arg
end = arg
if (not isinstance(arg, Mul)):
return arg
while ((not (start == end)) | ((start == arg) & (end == arg))):
start = end
tmp = start.as_coeff_mul()
sigma_product = 1
com_product = 1
keeper = 1
for el in tmp[1]:
if isinstance(el, Pauli):
sigma_product *= el
elif (not el.is_commutative):
keeper = ((keeper * sigma_product) * el)
sigma_product = 1
else:
com_product *= el
end = (((tmp[0] * keeper) * sigma_product) * com_product)
if (end == arg):
break
return end
| [
"def",
"evaluate_pauli_product",
"(",
"arg",
")",
":",
"start",
"=",
"arg",
"end",
"=",
"arg",
"if",
"(",
"not",
"isinstance",
"(",
"arg",
",",
"Mul",
")",
")",
":",
"return",
"arg",
"while",
"(",
"(",
"not",
"(",
"start",
"==",
"end",
")",
")",
... | help function to evaluate pauli matrices product with symbolic objects parameters arg: symbolic expression that contains paulimatrices examples . | train | false |
5,914 | def _update_object(table, table_obj):
_db_content[table][table_obj.obj] = table_obj
| [
"def",
"_update_object",
"(",
"table",
",",
"table_obj",
")",
":",
"_db_content",
"[",
"table",
"]",
"[",
"table_obj",
".",
"obj",
"]",
"=",
"table_obj"
] | update objects of the type . | train | false |
5,916 | def _set_to_get(set_cmd, module):
set_cmd = truncate_before(set_cmd, ' option:')
get_cmd = set_cmd.split(' ')
(key, value) = get_cmd[(-1)].split('=')
module.log(('get commands %s ' % key))
return (((['--', 'get'] + get_cmd[:(-1)]) + [key]), value)
| [
"def",
"_set_to_get",
"(",
"set_cmd",
",",
"module",
")",
":",
"set_cmd",
"=",
"truncate_before",
"(",
"set_cmd",
",",
"' option:'",
")",
"get_cmd",
"=",
"set_cmd",
".",
"split",
"(",
"' '",
")",
"(",
"key",
",",
"value",
")",
"=",
"get_cmd",
"[",
"(",... | convert set command to get command and set value . | train | false |
5,918 | def _convert_comp_data(res4):
if (res4['ncomp'] == 0):
return
res4['comp'] = sorted(res4['comp'], key=_comp_sort_keys)
_check_comp(res4['comp'])
first = 0
kind = (-1)
comps = list()
for k in range(len(res4['comp'])):
if (res4['comp'][k]['coeff_type'] != kind):
if (k > 0):
comps.append(_conv_comp(res4['comp'], first, (k - 1), res4['chs']))
kind = res4['comp'][k]['coeff_type']
first = k
comps.append(_conv_comp(res4['comp'], first, k, res4['chs']))
return comps
| [
"def",
"_convert_comp_data",
"(",
"res4",
")",
":",
"if",
"(",
"res4",
"[",
"'ncomp'",
"]",
"==",
"0",
")",
":",
"return",
"res4",
"[",
"'comp'",
"]",
"=",
"sorted",
"(",
"res4",
"[",
"'comp'",
"]",
",",
"key",
"=",
"_comp_sort_keys",
")",
"_check_co... | convert the compensation data into named matrices . | train | false |
5,919 | def _get_cibfile_cksum(cibname):
cibfile_cksum = '{0}.cksum'.format(_get_cibfile(cibname))
log.trace('cibfile_cksum: {0}'.format(cibfile_cksum))
return cibfile_cksum
| [
"def",
"_get_cibfile_cksum",
"(",
"cibname",
")",
":",
"cibfile_cksum",
"=",
"'{0}.cksum'",
".",
"format",
"(",
"_get_cibfile",
"(",
"cibname",
")",
")",
"log",
".",
"trace",
"(",
"'cibfile_cksum: {0}'",
".",
"format",
"(",
"cibfile_cksum",
")",
")",
"return",... | get the full path of the file containing a checksum of a cib-file with the name of the cib . | train | true |
5,921 | def vhost_exists(name, runas=None):
if ((runas is None) and (not salt.utils.is_windows())):
runas = salt.utils.get_user()
return (name in list_vhosts(runas=runas))
| [
"def",
"vhost_exists",
"(",
"name",
",",
"runas",
"=",
"None",
")",
":",
"if",
"(",
"(",
"runas",
"is",
"None",
")",
"and",
"(",
"not",
"salt",
".",
"utils",
".",
"is_windows",
"(",
")",
")",
")",
":",
"runas",
"=",
"salt",
".",
"utils",
".",
"... | return whether the vhost exists based on rabbitmqctl list_vhosts . | train | true |
5,922 | def day_crumb(date):
year = date.strftime('%Y')
month = date.strftime('%m')
day = date.strftime('%d')
return Crumb(day, reverse('zinnia:entry_archive_day', args=[year, month, day]))
| [
"def",
"day_crumb",
"(",
"date",
")",
":",
"year",
"=",
"date",
".",
"strftime",
"(",
"'%Y'",
")",
"month",
"=",
"date",
".",
"strftime",
"(",
"'%m'",
")",
"day",
"=",
"date",
".",
"strftime",
"(",
"'%d'",
")",
"return",
"Crumb",
"(",
"day",
",",
... | crumb for a day . | train | true |
5,924 | def find_management_module(app_name):
parts = app_name.split('.')
parts.append('management')
parts.reverse()
part = parts.pop()
path = None
try:
(f, path, descr) = imp.find_module(part, path)
except ImportError as e:
if (os.path.basename(os.getcwd()) != part):
raise e
while parts:
part = parts.pop()
(f, path, descr) = imp.find_module(part, ((path and [path]) or None))
return path
| [
"def",
"find_management_module",
"(",
"app_name",
")",
":",
"parts",
"=",
"app_name",
".",
"split",
"(",
"'.'",
")",
"parts",
".",
"append",
"(",
"'management'",
")",
"parts",
".",
"reverse",
"(",
")",
"part",
"=",
"parts",
".",
"pop",
"(",
")",
"path"... | determines the path to the management module for the given app_name . | train | false |
5,925 | def warnAboutFunction(offender, warningString):
offenderModule = sys.modules[offender.__module__]
filename = inspect.getabsfile(offenderModule)
lineStarts = list(findlinestarts(offender.func_code))
lastLineNo = lineStarts[(-1)][1]
globals = offender.func_globals
kwargs = dict(category=DeprecationWarning, filename=filename, lineno=lastLineNo, module=offenderModule.__name__, registry=globals.setdefault('__warningregistry__', {}), module_globals=None)
if (sys.version_info[:2] < (2, 5)):
kwargs.pop('module_globals')
warn_explicit(warningString, **kwargs)
| [
"def",
"warnAboutFunction",
"(",
"offender",
",",
"warningString",
")",
":",
"offenderModule",
"=",
"sys",
".",
"modules",
"[",
"offender",
".",
"__module__",
"]",
"filename",
"=",
"inspect",
".",
"getabsfile",
"(",
"offenderModule",
")",
"lineStarts",
"=",
"l... | issue a warning string . | train | false |
5,926 | def processArchivable(archivableClass, elementNode):
if (elementNode == None):
return
elementNode.xmlObject = archivableClass()
elementNode.xmlObject.setToElementNode(elementNode)
elementNode.getXMLProcessor().processChildNodes(elementNode)
| [
"def",
"processArchivable",
"(",
"archivableClass",
",",
"elementNode",
")",
":",
"if",
"(",
"elementNode",
"==",
"None",
")",
":",
"return",
"elementNode",
".",
"xmlObject",
"=",
"archivableClass",
"(",
")",
"elementNode",
".",
"xmlObject",
".",
"setToElementNo... | get any new elements and process the archivable . | train | false |
5,927 | @profiler.trace
def port_create(request, network_id, **kwargs):
LOG.debug(('port_create(): netid=%s, kwargs=%s' % (network_id, kwargs)))
if ('policy_profile_id' in kwargs):
kwargs['n1kv:profile'] = kwargs.pop('policy_profile_id')
kwargs = unescape_port_kwargs(**kwargs)
body = {'port': {'network_id': network_id}}
if ('tenant_id' not in kwargs):
kwargs['tenant_id'] = request.user.project_id
body['port'].update(kwargs)
port = neutronclient(request).create_port(body=body).get('port')
return Port(port)
| [
"@",
"profiler",
".",
"trace",
"def",
"port_create",
"(",
"request",
",",
"network_id",
",",
"**",
"kwargs",
")",
":",
"LOG",
".",
"debug",
"(",
"(",
"'port_create(): netid=%s, kwargs=%s'",
"%",
"(",
"network_id",
",",
"kwargs",
")",
")",
")",
"if",
"(",
... | create a port on a specified network . | train | true |
5,930 | def _get_direct_filter_query(args):
query = Q()
for arg in args:
if (hasattr(Document, arg) and args[arg]):
append = Q(**{str((arg + '__id')): long(args[arg])})
query = (query & append)
return query
| [
"def",
"_get_direct_filter_query",
"(",
"args",
")",
":",
"query",
"=",
"Q",
"(",
")",
"for",
"arg",
"in",
"args",
":",
"if",
"(",
"hasattr",
"(",
"Document",
",",
"arg",
")",
"and",
"args",
"[",
"arg",
"]",
")",
":",
"append",
"=",
"Q",
"(",
"**... | creates a query to filter documents . | train | false |
5,932 | def _convert_fits2record(format):
(repeat, dtype, option) = _parse_tformat(format)
if (dtype in FITS2NUMPY):
if (dtype == 'A'):
output_format = (FITS2NUMPY[dtype] + str(repeat))
if ((format.lstrip()[0] == 'A') and (option != '')):
output_format = (FITS2NUMPY[dtype] + str(int(option)))
else:
repeat_str = ''
if (repeat != 1):
repeat_str = str(repeat)
output_format = (repeat_str + FITS2NUMPY[dtype])
elif (dtype == 'X'):
output_format = _FormatX(repeat)
elif (dtype == 'P'):
output_format = _FormatP.from_tform(format)
elif (dtype == 'Q'):
output_format = _FormatQ.from_tform(format)
elif (dtype == 'F'):
output_format = 'f8'
else:
raise ValueError('Illegal format {}.'.format(format))
return output_format
| [
"def",
"_convert_fits2record",
"(",
"format",
")",
":",
"(",
"repeat",
",",
"dtype",
",",
"option",
")",
"=",
"_parse_tformat",
"(",
"format",
")",
"if",
"(",
"dtype",
"in",
"FITS2NUMPY",
")",
":",
"if",
"(",
"dtype",
"==",
"'A'",
")",
":",
"output_for... | convert fits format spec to record format spec . | train | false |
5,933 | def is_template_file(path):
ext = os.path.splitext(path)[1].lower()
return (ext in [u'.html', u'.htm', u'.xml'])
| [
"def",
"is_template_file",
"(",
"path",
")",
":",
"ext",
"=",
"os",
".",
"path",
".",
"splitext",
"(",
"path",
")",
"[",
"1",
"]",
".",
"lower",
"(",
")",
"return",
"(",
"ext",
"in",
"[",
"u'.html'",
",",
"u'.htm'",
",",
"u'.xml'",
"]",
")"
] | return true if the given file path is an html file . | train | false |
5,934 | def register_reader(data_format, data_class, function, force=False):
if ((not ((data_format, data_class) in _readers)) or force):
_readers[(data_format, data_class)] = function
else:
raise IORegistryError(u"Reader for format '{0}' and class '{1}' is already defined".format(data_format, data_class.__name__))
if (data_class not in _delayed_docs_classes):
_update__doc__(data_class, u'read')
| [
"def",
"register_reader",
"(",
"data_format",
",",
"data_class",
",",
"function",
",",
"force",
"=",
"False",
")",
":",
"if",
"(",
"(",
"not",
"(",
"(",
"data_format",
",",
"data_class",
")",
"in",
"_readers",
")",
")",
"or",
"force",
")",
":",
"_reade... | register a reader function . | train | false |
5,936 | def _akima_interpolate(xi, yi, x, der=0, axis=0):
from scipy import interpolate
try:
P = interpolate.Akima1DInterpolator(xi, yi, axis=axis)
except TypeError:
P = interpolate.Akima1DInterpolator(xi, yi)
if (der == 0):
return P(x)
elif interpolate._isscalar(der):
return P(x, der=der)
else:
return [P(x, nu) for nu in der]
| [
"def",
"_akima_interpolate",
"(",
"xi",
",",
"yi",
",",
"x",
",",
"der",
"=",
"0",
",",
"axis",
"=",
"0",
")",
":",
"from",
"scipy",
"import",
"interpolate",
"try",
":",
"P",
"=",
"interpolate",
".",
"Akima1DInterpolator",
"(",
"xi",
",",
"yi",
",",
... | convenience function for akima interpolation . | train | true |
5,937 | def encode_utf8(string):
if isinstance(string, unicode):
try:
return string.encode('utf-8')
except:
return string
return str(string)
| [
"def",
"encode_utf8",
"(",
"string",
")",
":",
"if",
"isinstance",
"(",
"string",
",",
"unicode",
")",
":",
"try",
":",
"return",
"string",
".",
"encode",
"(",
"'utf-8'",
")",
"except",
":",
"return",
"string",
"return",
"str",
"(",
"string",
")"
] | encode a utf-8 string to a sequence of bytes . | train | false |
5,940 | def test_named_import():
s = 'import time as dt'
assert (len(Script(s, 1, 15, '/').goto_definitions()) == 1)
assert (len(Script(s, 1, 10, '/').goto_definitions()) == 1)
| [
"def",
"test_named_import",
"(",
")",
":",
"s",
"=",
"'import time as dt'",
"assert",
"(",
"len",
"(",
"Script",
"(",
"s",
",",
"1",
",",
"15",
",",
"'/'",
")",
".",
"goto_definitions",
"(",
")",
")",
"==",
"1",
")",
"assert",
"(",
"len",
"(",
"Scr... | named import - jedi-vim issue #8 . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.