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 |
|---|---|---|---|---|---|
4,168 | def split_on_groups(string, groups):
if (not groups):
return [string]
boundaries = sorted(set(functools.reduce((lambda l, x: (l + list(x))), groups, [])))
if (boundaries[0] != 0):
boundaries.insert(0, 0)
if (boundaries[(-1)] != len(string)):
boundaries.append(len(string))
groups = [string[start:end] for (start, end) in zip(boundaries[:(-1)], boundaries[1:])]
return [g for g in groups if g]
| [
"def",
"split_on_groups",
"(",
"string",
",",
"groups",
")",
":",
"if",
"(",
"not",
"groups",
")",
":",
"return",
"[",
"string",
"]",
"boundaries",
"=",
"sorted",
"(",
"set",
"(",
"functools",
".",
"reduce",
"(",
"(",
"lambda",
"l",
",",
"x",
":",
... | split the given string using the different known groups for boundaries . | train | false |
4,169 | def _GetUserSecret(user):
secret = secrets.GetSecret(_SecretName(user))
if (not secret):
raise LookupError('no secret has been created for {0}'.format(user))
return secret
| [
"def",
"_GetUserSecret",
"(",
"user",
")",
":",
"secret",
"=",
"secrets",
".",
"GetSecret",
"(",
"_SecretName",
"(",
"user",
")",
")",
"if",
"(",
"not",
"secret",
")",
":",
"raise",
"LookupError",
"(",
"'no secret has been created for {0}'",
".",
"format",
"... | returns the user secret by consulting the secrets database . | train | false |
4,173 | def find_hessian_diag(point, vars=None, model=None):
model = modelcontext(model)
H = model.fastfn(hessian_diag(model.logpt, vars))
return H(Point(point, model=model))
| [
"def",
"find_hessian_diag",
"(",
"point",
",",
"vars",
"=",
"None",
",",
"model",
"=",
"None",
")",
":",
"model",
"=",
"modelcontext",
"(",
"model",
")",
"H",
"=",
"model",
".",
"fastfn",
"(",
"hessian_diag",
"(",
"model",
".",
"logpt",
",",
"vars",
... | returns hessian of logp at the point passed . | train | false |
4,174 | def neg(a):
return (- a)
| [
"def",
"neg",
"(",
"a",
")",
":",
"return",
"(",
"-",
"a",
")"
] | alias for -min_elemwise{x . | train | false |
4,175 | @with_setup(prepare_stdout, registry.clear)
def test_jsonreport_output_with_one_error():
with check_jsonreport(u'error_traceback'):
runner = Runner(feature_name(u'error_traceback'), enable_jsonreport=True)
runner.run()
| [
"@",
"with_setup",
"(",
"prepare_stdout",
",",
"registry",
".",
"clear",
")",
"def",
"test_jsonreport_output_with_one_error",
"(",
")",
":",
"with",
"check_jsonreport",
"(",
"u'error_traceback'",
")",
":",
"runner",
"=",
"Runner",
"(",
"feature_name",
"(",
"u'erro... | test jsonreport output with one errors . | train | false |
4,178 | def partition_entropy_by(inputs, attribute):
partitions = partition_by(inputs, attribute)
return partition_entropy(partitions.values())
| [
"def",
"partition_entropy_by",
"(",
"inputs",
",",
"attribute",
")",
":",
"partitions",
"=",
"partition_by",
"(",
"inputs",
",",
"attribute",
")",
"return",
"partition_entropy",
"(",
"partitions",
".",
"values",
"(",
")",
")"
] | computes the entropy corresponding to the given partition . | train | false |
4,180 | def imports_on_separate_lines(logical_line):
line = logical_line
if line.startswith('import '):
found = line.find(',')
if (((-1) < found) and (';' not in line[:found])):
(yield (found, 'E401 multiple imports on one line'))
| [
"def",
"imports_on_separate_lines",
"(",
"logical_line",
")",
":",
"line",
"=",
"logical_line",
"if",
"line",
".",
"startswith",
"(",
"'import '",
")",
":",
"found",
"=",
"line",
".",
"find",
"(",
"','",
")",
"if",
"(",
"(",
"(",
"-",
"1",
")",
"<",
... | imports should usually be on separate lines . | train | true |
4,181 | def modified_time(file_path):
if os.path.exists(file_path):
return os.path.getmtime(file_path)
else:
return 0.0
| [
"def",
"modified_time",
"(",
"file_path",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"file_path",
")",
":",
"return",
"os",
".",
"path",
".",
"getmtime",
"(",
"file_path",
")",
"else",
":",
"return",
"0.0"
] | return the modified time of the supplied file . | train | false |
4,183 | def webapi_deprecated(deprecated_in, force_error_http_status=None, default_api_format=None, encoders=[]):
def _dec(view_func):
def _view(*args, **kwargs):
if default_api_format:
request = args[0]
assert isinstance(request, HttpRequest)
method_args = getattr(request, request.method, None)
if (method_args and (u'api_format' not in method_args)):
method_args = method_args.copy()
method_args[u'api_format'] = default_api_format
setattr(request, request.method, method_args)
response = view_func(*args, **kwargs)
if isinstance(response, WebAPIResponse):
response.encoders = encoders
if isinstance(response, WebAPIResponseError):
response.api_data[u'deprecated'] = {u'in_version': deprecated_in}
if (force_error_http_status and isinstance(response, WebAPIResponseError)):
response.status_code = force_error_http_status
return response
return _view
return _dec
| [
"def",
"webapi_deprecated",
"(",
"deprecated_in",
",",
"force_error_http_status",
"=",
"None",
",",
"default_api_format",
"=",
"None",
",",
"encoders",
"=",
"[",
"]",
")",
":",
"def",
"_dec",
"(",
"view_func",
")",
":",
"def",
"_view",
"(",
"*",
"args",
",... | marks an api handler as deprecated . | train | false |
4,184 | def primary_key_names(model):
mapper = sqlalchemy_inspect(model)
return [column.name for column in mapper.primary_key]
| [
"def",
"primary_key_names",
"(",
"model",
")",
":",
"mapper",
"=",
"sqlalchemy_inspect",
"(",
"model",
")",
"return",
"[",
"column",
".",
"name",
"for",
"column",
"in",
"mapper",
".",
"primary_key",
"]"
] | returns a list of all the primary keys for a model . | train | false |
4,185 | def stem(word, cached=True, history=10000, **kwargs):
stem = word.lower()
if (cached and (stem in cache)):
return case_sensitive(cache[stem], word)
if (cached and (len(cache) > history)):
cache.clear()
if (len(stem) <= 2):
return case_sensitive(stem, word)
if (stem in exceptions):
return case_sensitive(exceptions[stem], word)
if (stem in uninflected):
return case_sensitive(stem, word)
stem = upper_consonant_y(stem)
for f in (step_1a, step_1b, step_1c, step_2, step_3, step_4, step_5a, step_5b):
stem = f(stem)
stem = stem.lower()
stem = case_sensitive(stem, word)
if cached:
cache[word.lower()] = stem.lower()
return stem
| [
"def",
"stem",
"(",
"word",
",",
"cached",
"=",
"True",
",",
"history",
"=",
"10000",
",",
"**",
"kwargs",
")",
":",
"stem",
"=",
"word",
".",
"lower",
"(",
")",
"if",
"(",
"cached",
"and",
"(",
"stem",
"in",
"cache",
")",
")",
":",
"return",
"... | returns the stemmed version of the argument string . | train | false |
4,186 | def unit_propagate(clauses, symbol):
output = []
for c in clauses:
if (c.func != Or):
output.append(c)
continue
for arg in c.args:
if (arg == (~ symbol)):
output.append(Or(*[x for x in c.args if (x != (~ symbol))]))
break
if (arg == symbol):
break
else:
output.append(c)
return output
| [
"def",
"unit_propagate",
"(",
"clauses",
",",
"symbol",
")",
":",
"output",
"=",
"[",
"]",
"for",
"c",
"in",
"clauses",
":",
"if",
"(",
"c",
".",
"func",
"!=",
"Or",
")",
":",
"output",
".",
"append",
"(",
"c",
")",
"continue",
"for",
"arg",
"in"... | returns an equivalent set of clauses if a set of clauses contains the unit clause l . | train | false |
4,188 | def extract_components_from_tuple(repository_components_tuple):
toolshed = repository_components_tuple[0]
name = repository_components_tuple[1]
owner = repository_components_tuple[2]
changeset_revision = repository_components_tuple[3]
components_list = [toolshed, name, owner, changeset_revision]
if (len(repository_components_tuple) == 5):
(toolshed, name, owner, changeset_revision, prior_installation_required) = repository_components_tuple
components_list = [toolshed, name, owner, changeset_revision, prior_installation_required]
elif (len(repository_components_tuple) == 6):
(toolshed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td) = repository_components_tuple
components_list = [toolshed, name, owner, changeset_revision, prior_installation_required, only_if_compiling_contained_td]
return components_list
| [
"def",
"extract_components_from_tuple",
"(",
"repository_components_tuple",
")",
":",
"toolshed",
"=",
"repository_components_tuple",
"[",
"0",
"]",
"name",
"=",
"repository_components_tuple",
"[",
"1",
"]",
"owner",
"=",
"repository_components_tuple",
"[",
"2",
"]",
... | extract the repository components from the provided tuple in a backward-compatible manner . | train | false |
4,189 | def bin2long(text, endian):
assert (endian in (LITTLE_ENDIAN, BIG_ENDIAN))
bits = [(ord(character) - ord('0')) for character in text if (character in '01')]
assert (len(bits) != 0)
if (endian is not BIG_ENDIAN):
bits = reversed(bits)
value = 0
for bit in bits:
value *= 2
value += bit
return value
| [
"def",
"bin2long",
"(",
"text",
",",
"endian",
")",
":",
"assert",
"(",
"endian",
"in",
"(",
"LITTLE_ENDIAN",
",",
"BIG_ENDIAN",
")",
")",
"bits",
"=",
"[",
"(",
"ord",
"(",
"character",
")",
"-",
"ord",
"(",
"'0'",
")",
")",
"for",
"character",
"i... | convert binary number written in a string into an integer . | train | false |
4,190 | def absdir(path):
if (not os.path.isabs(path)):
path = os.path.normpath(os.path.abspath(os.path.join(os.getcwd(), path)))
if ((path is None) or (not os.path.isdir(path))):
return None
return path
| [
"def",
"absdir",
"(",
"path",
")",
":",
"if",
"(",
"not",
"os",
".",
"path",
".",
"isabs",
"(",
"path",
")",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"normpath",
"(",
"os",
".",
"path",
".",
"abspath",
"(",
"os",
".",
"path",
".",
"join... | return absolute . | train | true |
4,191 | def initialize_scheduler():
from headphones import updater, searcher, librarysync, postprocessor, torrentfinished
with SCHED_LOCK:
start_jobs = (not len(SCHED.get_jobs()))
minutes = CONFIG.SEARCH_INTERVAL
schedule_job(searcher.searchforalbum, 'Search for Wanted', hours=0, minutes=minutes)
minutes = CONFIG.DOWNLOAD_SCAN_INTERVAL
schedule_job(postprocessor.checkFolder, 'Download Scan', hours=0, minutes=minutes)
hours = CONFIG.LIBRARYSCAN_INTERVAL
schedule_job(librarysync.libraryScan, 'Library Scan', hours=hours, minutes=0)
hours = CONFIG.UPDATE_DB_INTERVAL
schedule_job(updater.dbUpdate, 'MusicBrainz Update', hours=hours, minutes=0)
if CONFIG.CHECK_GITHUB:
if CONFIG.CHECK_GITHUB_INTERVAL:
minutes = CONFIG.CHECK_GITHUB_INTERVAL
else:
minutes = 0
schedule_job(versioncheck.checkGithub, 'Check GitHub for updates', hours=0, minutes=minutes)
minutes = CONFIG.TORRENT_REMOVAL_INTERVAL
schedule_job(torrentfinished.checkTorrentFinished, 'Torrent removal check', hours=0, minutes=minutes)
if (start_jobs and len(SCHED.get_jobs())):
try:
SCHED.start()
except Exception as e:
logger.info(e)
| [
"def",
"initialize_scheduler",
"(",
")",
":",
"from",
"headphones",
"import",
"updater",
",",
"searcher",
",",
"librarysync",
",",
"postprocessor",
",",
"torrentfinished",
"with",
"SCHED_LOCK",
":",
"start_jobs",
"=",
"(",
"not",
"len",
"(",
"SCHED",
".",
"get... | start the scheduled background tasks . | train | false |
4,192 | def buildDecomposableNetwork():
n = buildNetwork(2, 3, 2, bias=False)
ndc = NeuronDecomposableNetwork.convertNormalNetwork(n)
ndc._setParameters(ones(12))
return ndc
| [
"def",
"buildDecomposableNetwork",
"(",
")",
":",
"n",
"=",
"buildNetwork",
"(",
"2",
",",
"3",
",",
"2",
",",
"bias",
"=",
"False",
")",
"ndc",
"=",
"NeuronDecomposableNetwork",
".",
"convertNormalNetwork",
"(",
"n",
")",
"ndc",
".",
"_setParameters",
"("... | three hidden neurons . | train | false |
4,196 | def _edge_betweenness(G, source, nodes=None, cutoff=False):
(pred, length) = nx.predecessor(G, source, cutoff=cutoff, return_seen=True)
onodes = [n for (n, d) in sorted(length.items(), key=itemgetter(1))]
between = {}
for (u, v) in G.edges(nodes):
between[(u, v)] = 1.0
between[(v, u)] = 1.0
while onodes:
v = onodes.pop()
if (v in pred):
num_paths = len(pred[v])
for w in pred[v]:
if (w in pred):
num_paths = len(pred[w])
for x in pred[w]:
between[(w, x)] += (between[(v, w)] / num_paths)
between[(x, w)] += (between[(w, v)] / num_paths)
return between
| [
"def",
"_edge_betweenness",
"(",
"G",
",",
"source",
",",
"nodes",
"=",
"None",
",",
"cutoff",
"=",
"False",
")",
":",
"(",
"pred",
",",
"length",
")",
"=",
"nx",
".",
"predecessor",
"(",
"G",
",",
"source",
",",
"cutoff",
"=",
"cutoff",
",",
"retu... | edge betweenness helper . | train | false |
4,197 | def referenced(word, article=INDEFINITE, gender=MALE, role=SUBJECT):
return ('%s %s' % (_article(word, article, gender, role), word))
| [
"def",
"referenced",
"(",
"word",
",",
"article",
"=",
"INDEFINITE",
",",
"gender",
"=",
"MALE",
",",
"role",
"=",
"SUBJECT",
")",
":",
"return",
"(",
"'%s %s'",
"%",
"(",
"_article",
"(",
"word",
",",
"article",
",",
"gender",
",",
"role",
")",
",",... | returns a string with the article + the word . | train | true |
4,198 | def p_boolean_document(corpus, segmented_topics):
top_ids = _ret_top_ids(segmented_topics)
per_topic_postings = {}
for id in top_ids:
id_list = set()
for (n, document) in enumerate(corpus):
if (id in frozenset((x[0] for x in document))):
id_list.add(n)
per_topic_postings[id] = id_list
num_docs = len(corpus)
return (per_topic_postings, num_docs)
| [
"def",
"p_boolean_document",
"(",
"corpus",
",",
"segmented_topics",
")",
":",
"top_ids",
"=",
"_ret_top_ids",
"(",
"segmented_topics",
")",
"per_topic_postings",
"=",
"{",
"}",
"for",
"id",
"in",
"top_ids",
":",
"id_list",
"=",
"set",
"(",
")",
"for",
"(",
... | this function performs the boolean document probability estimation . | train | false |
4,199 | def parse_denoiser_mapping(denoiser_map):
result = {}
for line in denoiser_map:
line = line.strip().split(' DCTB ')
denoised_id = line[0].rstrip(':')
original_ids = ([denoised_id] + line[1:])
if (denoised_id in result):
raise ValueError('Duplicated identifiers in denoiser mapping file: are you sure you merged the correct files?')
else:
result[denoised_id] = original_ids
return result
| [
"def",
"parse_denoiser_mapping",
"(",
"denoiser_map",
")",
":",
"result",
"=",
"{",
"}",
"for",
"line",
"in",
"denoiser_map",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
".",
"split",
"(",
"' DCTB '",
")",
"denoised_id",
"=",
"line",
"[",
"0",
"]... | read a denoiser mapping file into a dictionary . | train | false |
4,200 | def save_reg(data):
reg_dir = _reg_dir()
regfile = os.path.join(reg_dir, 'register')
try:
if (not os.path.exists()):
os.makedirs(reg_dir)
except OSError as exc:
if (exc.errno == errno.EEXIST):
pass
else:
raise
try:
with salt.utils.fopen(regfile, 'a') as fh_:
msgpack.dump(data, fh_)
fh_.close()
except:
log.error('Could not write to msgpack file {0}'.format(__opts__['outdir']))
raise
| [
"def",
"save_reg",
"(",
"data",
")",
":",
"reg_dir",
"=",
"_reg_dir",
"(",
")",
"regfile",
"=",
"os",
".",
"path",
".",
"join",
"(",
"reg_dir",
",",
"'register'",
")",
"try",
":",
"if",
"(",
"not",
"os",
".",
"path",
".",
"exists",
"(",
")",
")",... | save the register to msgpack files . | train | true |
4,201 | def GetOwnerIDs(region):
ec2 = _Connect(region)
return [g.owner_id for g in ec2.get_all_security_groups()]
| [
"def",
"GetOwnerIDs",
"(",
"region",
")",
":",
"ec2",
"=",
"_Connect",
"(",
"region",
")",
"return",
"[",
"g",
".",
"owner_id",
"for",
"g",
"in",
"ec2",
".",
"get_all_security_groups",
"(",
")",
"]"
] | return the list of owner ids in this regions security groups . | train | false |
4,202 | def get_model_field_name(field):
field = slugify(field)
field = field.replace('-', '_')
field = field.replace(':', '_')
if (field in ('id',)):
field += '_'
if (field.upper() in PG_RESERVED_KEYWORDS):
field += '_'
if (field[(-1):] == '_'):
field += 'field'
try:
int(field)
float(field)
field = ('_%s' % field)
except ValueError:
pass
return field
| [
"def",
"get_model_field_name",
"(",
"field",
")",
":",
"field",
"=",
"slugify",
"(",
"field",
")",
"field",
"=",
"field",
".",
"replace",
"(",
"'-'",
",",
"'_'",
")",
"field",
"=",
"field",
".",
"replace",
"(",
"':'",
",",
"'_'",
")",
"if",
"(",
"f... | get the field name usable without quotes . | train | false |
4,204 | def appendTextElements(e, contentsList, se):
def uconcat(text, newText, se):
if (type(newText) != type(text)):
if (type(text) is str):
text = text.decode(se)
else:
newText = newText.decode(se)
return (text + newText)
e.text = ''
lastElement = None
for content in contentsList:
if (not isinstance(content, Text)):
newElement = content.toElement(se)
if (newElement is None):
continue
lastElement = newElement
lastElement.tail = ''
e.append(lastElement)
elif (lastElement is None):
e.text = uconcat(e.text, content.text, se)
else:
lastElement.tail = uconcat(lastElement.tail, content.text, se)
| [
"def",
"appendTextElements",
"(",
"e",
",",
"contentsList",
",",
"se",
")",
":",
"def",
"uconcat",
"(",
"text",
",",
"newText",
",",
"se",
")",
":",
"if",
"(",
"type",
"(",
"newText",
")",
"!=",
"type",
"(",
"text",
")",
")",
":",
"if",
"(",
"typ... | a helper function to convert text streams into the proper elements . | train | false |
4,206 | def update_patch_log(patchmodule):
frappe.get_doc({u'doctype': u'Patch Log', u'patch': patchmodule}).insert()
| [
"def",
"update_patch_log",
"(",
"patchmodule",
")",
":",
"frappe",
".",
"get_doc",
"(",
"{",
"u'doctype'",
":",
"u'Patch Log'",
",",
"u'patch'",
":",
"patchmodule",
"}",
")",
".",
"insert",
"(",
")"
] | update patch_file in patch log . | train | false |
4,209 | def ExampleGen(data_path, num_epochs=None):
epoch = 0
while True:
if ((num_epochs is not None) and (epoch >= num_epochs)):
break
filelist = glob.glob(data_path)
assert filelist, 'Empty filelist.'
random.shuffle(filelist)
for f in filelist:
reader = open(f, 'rb')
while True:
len_bytes = reader.read(8)
if (not len_bytes):
break
str_len = struct.unpack('q', len_bytes)[0]
example_str = struct.unpack(('%ds' % str_len), reader.read(str_len))[0]
(yield example_pb2.Example.FromString(example_str))
epoch += 1
| [
"def",
"ExampleGen",
"(",
"data_path",
",",
"num_epochs",
"=",
"None",
")",
":",
"epoch",
"=",
"0",
"while",
"True",
":",
"if",
"(",
"(",
"num_epochs",
"is",
"not",
"None",
")",
"and",
"(",
"epoch",
">=",
"num_epochs",
")",
")",
":",
"break",
"fileli... | generates tf . | train | false |
4,212 | def is_installed(pkg_name):
with settings(warn_only=True):
res = run(('pkg_info -e %s' % pkg_name))
return (res.succeeded is True)
| [
"def",
"is_installed",
"(",
"pkg_name",
")",
":",
"with",
"settings",
"(",
"warn_only",
"=",
"True",
")",
":",
"res",
"=",
"run",
"(",
"(",
"'pkg_info -e %s'",
"%",
"pkg_name",
")",
")",
"return",
"(",
"res",
".",
"succeeded",
"is",
"True",
")"
] | returns true if a model_class is installed . | train | false |
4,213 | def true(*args, **kwargs):
return True
| [
"def",
"true",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"return",
"True"
] | always returns true . | train | false |
4,214 | def print_name_status(changes):
for change in changes:
if (not change):
continue
if (type(change) is list):
change = change[0]
if (change.type == CHANGE_ADD):
path1 = change.new.path
path2 = ''
kind = 'A'
elif (change.type == CHANGE_DELETE):
path1 = change.old.path
path2 = ''
kind = 'D'
elif (change.type == CHANGE_MODIFY):
path1 = change.new.path
path2 = ''
kind = 'M'
elif (change.type in RENAME_CHANGE_TYPES):
path1 = change.old.path
path2 = change.new.path
if (change.type == CHANGE_RENAME):
kind = 'R'
elif (change.type == CHANGE_COPY):
kind = 'C'
(yield ('%-8s%-20s%-20s' % (kind, path1, path2)))
| [
"def",
"print_name_status",
"(",
"changes",
")",
":",
"for",
"change",
"in",
"changes",
":",
"if",
"(",
"not",
"change",
")",
":",
"continue",
"if",
"(",
"type",
"(",
"change",
")",
"is",
"list",
")",
":",
"change",
"=",
"change",
"[",
"0",
"]",
"i... | print a simple status summary . | train | false |
4,215 | def fixReturns(line):
return re.sub('returns:', '@returns', line)
| [
"def",
"fixReturns",
"(",
"line",
")",
":",
"return",
"re",
".",
"sub",
"(",
"'returns:'",
",",
"'@returns'",
",",
"line",
")"
] | change returns: foo to @return foo . | train | false |
4,216 | def is_sys_meta(server_type, key):
if (len(key) <= (11 + len(server_type))):
return False
return key.lower().startswith(get_sys_meta_prefix(server_type))
| [
"def",
"is_sys_meta",
"(",
"server_type",
",",
"key",
")",
":",
"if",
"(",
"len",
"(",
"key",
")",
"<=",
"(",
"11",
"+",
"len",
"(",
"server_type",
")",
")",
")",
":",
"return",
"False",
"return",
"key",
".",
"lower",
"(",
")",
".",
"startswith",
... | tests if a header key starts with and is longer than the system metadata prefix for given server type . | train | false |
4,218 | def _StrOrUnicode(value):
try:
return str(value)
except UnicodeEncodeError:
return unicode(value)
| [
"def",
"_StrOrUnicode",
"(",
"value",
")",
":",
"try",
":",
"return",
"str",
"(",
"value",
")",
"except",
"UnicodeEncodeError",
":",
"return",
"unicode",
"(",
"value",
")"
] | converts value to a python string or . | train | false |
4,220 | def makeDir(path):
if (not ek(os.path.isdir, path)):
try:
ek(os.makedirs, path)
sickbeard.notifiers.synoindex_notifier.addFolder(path)
except OSError:
return False
return True
| [
"def",
"makeDir",
"(",
"path",
")",
":",
"if",
"(",
"not",
"ek",
"(",
"os",
".",
"path",
".",
"isdir",
",",
"path",
")",
")",
":",
"try",
":",
"ek",
"(",
"os",
".",
"makedirs",
",",
"path",
")",
"sickbeard",
".",
"notifiers",
".",
"synoindex_noti... | make a directory on the filesystem . | train | false |
4,221 | def FriendlyExceptionDlg(message):
class w3af_message_dialog(gtk.MessageDialog, ):
def dialog_response_cb(self, widget, response_id):
'\n http://faq.pygtk.org/index.py?req=show&file=faq10.017.htp\n '
self.destroy()
def dialog_run(self):
'\n http://faq.pygtk.org/index.py?req=show&file=faq10.017.htp\n '
if (not self.modal):
self.set_modal(True)
self.connect('response', self.dialog_response_cb)
self.show()
dlg = w3af_message_dialog(None, gtk.DIALOG_MODAL, gtk.MESSAGE_WARNING, gtk.BUTTONS_OK, message)
dlg.set_icon_from_file(W3AF_ICON)
dlg.set_title('Error')
dlg.dialog_run()
return
| [
"def",
"FriendlyExceptionDlg",
"(",
"message",
")",
":",
"class",
"w3af_message_dialog",
"(",
"gtk",
".",
"MessageDialog",
",",
")",
":",
"def",
"dialog_response_cb",
"(",
"self",
",",
"widget",
",",
"response_id",
")",
":",
"self",
".",
"destroy",
"(",
")",... | creates the dialog showing the message . | train | false |
4,222 | def _add_schema_entry(model_type, name, add_entry):
(schema_type, entity_meaning) = _GetSchemaEntryForPropertyType(model_type)
if (not schema_type):
return
entry = add_entry()
entry.set_name(name)
entry.set_type(schema_type)
if entity_meaning:
entry.set_meaning(entity_meaning)
| [
"def",
"_add_schema_entry",
"(",
"model_type",
",",
"name",
",",
"add_entry",
")",
":",
"(",
"schema_type",
",",
"entity_meaning",
")",
"=",
"_GetSchemaEntryForPropertyType",
"(",
"model_type",
")",
"if",
"(",
"not",
"schema_type",
")",
":",
"return",
"entry",
... | add single entry to schemaentries by invoking add_entry . | train | false |
4,223 | def make_2d(a):
a = np.atleast_2d(a.T).T
n = a.shape[0]
newshape = np.product(a.shape[1:]).astype(int)
a = a.reshape((n, newshape), order='F')
return a
| [
"def",
"make_2d",
"(",
"a",
")",
":",
"a",
"=",
"np",
".",
"atleast_2d",
"(",
"a",
".",
"T",
")",
".",
"T",
"n",
"=",
"a",
".",
"shape",
"[",
"0",
"]",
"newshape",
"=",
"np",
".",
"product",
"(",
"a",
".",
"shape",
"[",
"1",
":",
"]",
")"... | ravel the dimensions after the first . | train | false |
4,224 | def _make_cipher(initialization_vector, secret):
return AES.new(secret[:KEY_SIZE], AES.MODE_CBC, initialization_vector[:AES.block_size])
| [
"def",
"_make_cipher",
"(",
"initialization_vector",
",",
"secret",
")",
":",
"return",
"AES",
".",
"new",
"(",
"secret",
"[",
":",
"KEY_SIZE",
"]",
",",
"AES",
".",
"MODE_CBC",
",",
"initialization_vector",
"[",
":",
"AES",
".",
"block_size",
"]",
")"
] | return a block cipher object for use in encrypt and decrypt . | train | false |
4,228 | def swapaxes(x, axis1, axis2):
return Swapaxes(axis1, axis2)(x)
| [
"def",
"swapaxes",
"(",
"x",
",",
"axis1",
",",
"axis2",
")",
":",
"return",
"Swapaxes",
"(",
"axis1",
",",
"axis2",
")",
"(",
"x",
")"
] | swap axes of inputted tensor . | train | false |
4,229 | @pytest.mark.network
def test_download_vcs_link(script):
result = script.pip('install', '-d', '.', 'git+git://github.com/pypa/pip-test-package.git', expect_stderr=True)
assert ((Path('scratch') / 'pip-test-package-0.1.1.zip') in result.files_created)
assert ((script.site_packages / 'piptestpackage') not in result.files_created)
| [
"@",
"pytest",
".",
"mark",
".",
"network",
"def",
"test_download_vcs_link",
"(",
"script",
")",
":",
"result",
"=",
"script",
".",
"pip",
"(",
"'install'",
",",
"'-d'",
",",
"'.'",
",",
"'git+git://github.com/pypa/pip-test-package.git'",
",",
"expect_stderr",
"... | it should allow -d flag for vcs links . | train | false |
4,231 | def order_at_oo(a, d, t):
if a.is_zero:
return oo
return (d.degree(t) - a.degree(t))
| [
"def",
"order_at_oo",
"(",
"a",
",",
"d",
",",
"t",
")",
":",
"if",
"a",
".",
"is_zero",
":",
"return",
"oo",
"return",
"(",
"d",
".",
"degree",
"(",
"t",
")",
"-",
"a",
".",
"degree",
"(",
"t",
")",
")"
] | computes the order of a/d at oo . | train | false |
4,233 | def CreateCustomizerFeed(client, feed_name):
ad_customizer_feed_service = client.GetService('AdCustomizerFeedService')
customizer_feed = {'feedName': feed_name, 'feedAttributes': [{'type': 'STRING', 'name': 'Name'}, {'type': 'STRING', 'name': 'Price'}, {'type': 'DATE_TIME', 'name': 'Date'}]}
feed_service_operation = {'operator': 'ADD', 'operand': customizer_feed}
response = ad_customizer_feed_service.mutate([feed_service_operation])
if (response and ('value' in response)):
feed = response['value'][0]
feed_data = {'feedId': feed['feedId'], 'nameId': feed['feedAttributes'][0]['id'], 'priceId': feed['feedAttributes'][1]['id'], 'dateId': feed['feedAttributes'][2]['id']}
print ("Feed with name '%s' and ID %s was added with:\n DCTB Name attribute ID %s and price attribute ID %s and date attributeID %s" % (feed['feedName'], feed['feedId'], feed_data['nameId'], feed_data['priceId'], feed_data['dateId']))
return feed
else:
raise errors.GoogleAdsError('No feeds were added')
| [
"def",
"CreateCustomizerFeed",
"(",
"client",
",",
"feed_name",
")",
":",
"ad_customizer_feed_service",
"=",
"client",
".",
"GetService",
"(",
"'AdCustomizerFeedService'",
")",
"customizer_feed",
"=",
"{",
"'feedName'",
":",
"feed_name",
",",
"'feedAttributes'",
":",
... | creates a new adcustomizerfeed . | train | true |
4,234 | def argument(*param_decls, **attrs):
def decorator(f):
ArgumentClass = attrs.pop('cls', Argument)
_param_memo(f, ArgumentClass(param_decls, **attrs))
return f
return decorator
| [
"def",
"argument",
"(",
"*",
"param_decls",
",",
"**",
"attrs",
")",
":",
"def",
"decorator",
"(",
"f",
")",
":",
"ArgumentClass",
"=",
"attrs",
".",
"pop",
"(",
"'cls'",
",",
"Argument",
")",
"_param_memo",
"(",
"f",
",",
"ArgumentClass",
"(",
"param_... | attaches an argument to the command . | train | true |
4,235 | @register.inclusion_tag('zinnia/tags/dummy.html')
def get_featured_entries(number=5, template='zinnia/tags/entries_featured.html'):
return {'template': template, 'entries': Entry.published.filter(featured=True)[:number]}
| [
"@",
"register",
".",
"inclusion_tag",
"(",
"'zinnia/tags/dummy.html'",
")",
"def",
"get_featured_entries",
"(",
"number",
"=",
"5",
",",
"template",
"=",
"'zinnia/tags/entries_featured.html'",
")",
":",
"return",
"{",
"'template'",
":",
"template",
",",
"'entries'"... | return the featured entries . | train | true |
4,236 | def validate_gs_bucket_name(bucket_name):
if (len(bucket_name) > MAX_BUCKET_LEN):
raise BackupValidationException(('Bucket name length should not be longer than %d' % MAX_BUCKET_LEN))
if (len(bucket_name) < MIN_BUCKET_LEN):
raise BackupValidationException(('Bucket name length should be longer than %d' % MIN_BUCKET_LEN))
if bucket_name.lower().startswith('goog'):
raise BackupValidationException('Bucket name should not start with a "goog" prefix')
bucket_elements = bucket_name.split('.')
for bucket_element in bucket_elements:
if (len(bucket_element) > MAX_BUCKET_SEGMENT_LEN):
raise BackupValidationException(('Segment length of bucket name should not be longer than %d' % MAX_BUCKET_SEGMENT_LEN))
if (not re.match(BUCKET_PATTERN, bucket_name)):
raise BackupValidationException(('Invalid bucket name "%s"' % bucket_name))
| [
"def",
"validate_gs_bucket_name",
"(",
"bucket_name",
")",
":",
"if",
"(",
"len",
"(",
"bucket_name",
")",
">",
"MAX_BUCKET_LEN",
")",
":",
"raise",
"BackupValidationException",
"(",
"(",
"'Bucket name length should not be longer than %d'",
"%",
"MAX_BUCKET_LEN",
")",
... | validate the format of the given bucket_name . | train | false |
4,237 | def start_event_loop_qt4(app=None):
if (app is None):
app = get_app_qt4([''])
if (not is_event_loop_running_qt4(app)):
app._in_event_loop = True
app.exec_()
app._in_event_loop = False
else:
app._in_event_loop = True
| [
"def",
"start_event_loop_qt4",
"(",
"app",
"=",
"None",
")",
":",
"if",
"(",
"app",
"is",
"None",
")",
":",
"app",
"=",
"get_app_qt4",
"(",
"[",
"''",
"]",
")",
"if",
"(",
"not",
"is_event_loop_running_qt4",
"(",
"app",
")",
")",
":",
"app",
".",
"... | start the qt4 event loop in a consistent manner . | train | true |
4,238 | def get_era_names(width='wide', locale=LC_TIME):
return Locale.parse(locale).eras[width]
| [
"def",
"get_era_names",
"(",
"width",
"=",
"'wide'",
",",
"locale",
"=",
"LC_TIME",
")",
":",
"return",
"Locale",
".",
"parse",
"(",
"locale",
")",
".",
"eras",
"[",
"width",
"]"
] | return the era names used by the locale for the specified format . | train | false |
4,241 | def dccDescribe(data):
orig_data = data
data = string.split(data)
if (len(data) < 4):
return orig_data
(dcctype, arg, address, port) = data[:4]
if ('.' in address):
pass
else:
try:
address = long(address)
except ValueError:
pass
else:
address = (((address >> 24) & 255), ((address >> 16) & 255), ((address >> 8) & 255), (address & 255))
address = string.join(map(str, map(int, address)), '.')
if (dcctype == 'SEND'):
filename = arg
size_txt = ''
if (len(data) >= 5):
try:
size = int(data[4])
size_txt = (' of size %d bytes' % (size,))
except ValueError:
pass
dcc_text = ("SEND for file '%s'%s at host %s, port %s" % (filename, size_txt, address, port))
elif (dcctype == 'CHAT'):
dcc_text = ('CHAT for host %s, port %s' % (address, port))
else:
dcc_text = orig_data
return dcc_text
| [
"def",
"dccDescribe",
"(",
"data",
")",
":",
"orig_data",
"=",
"data",
"data",
"=",
"string",
".",
"split",
"(",
"data",
")",
"if",
"(",
"len",
"(",
"data",
")",
"<",
"4",
")",
":",
"return",
"orig_data",
"(",
"dcctype",
",",
"arg",
",",
"address",... | given the data chunk from a dcc query . | train | false |
4,242 | def rpc(cmd=None, dest=None, format='xml', *args, **kwargs):
conn = __proxy__['junos.conn']()
ret = dict()
ret['out'] = True
op = dict()
if ('__pub_arg' in kwargs):
if isinstance(kwargs['__pub_arg'][(-1)], dict):
op.update(kwargs['__pub_arg'][(-1)])
else:
op.update(kwargs)
if ((dest is None) and (format != 'xml')):
log.warning('Format ignored as it is only used for output which is dumped in the file.')
write_response = ''
try:
if (cmd in ['get-config', 'get_config']):
filter_reply = None
if ('filter' in op):
filter_reply = etree.XML(op['filter'])
xml_reply = getattr(conn.rpc, cmd.replace('-', '_'))(filter_reply, options=op)
ret['message'] = jxmlease.parse(etree.tostring(xml_reply))
write_response = etree.tostring(xml_reply)
if ((dest is not None) and (format != 'xml')):
op.update({'format': format})
rpc_reply = getattr(conn.rpc, cmd.replace('-', '_'))(filter_reply, options=op)
if (format == 'json'):
write_response = json.dumps(rpc_reply, indent=1)
else:
write_response = rpc_reply.text
else:
xml_reply = getattr(conn.rpc, cmd.replace('-', '_'))(**op)
ret['message'] = jxmlease.parse(etree.tostring(xml_reply))
write_response = etree.tostring(xml_reply)
if ((dest is not None) and (format != 'xml')):
rpc_reply = getattr(conn.rpc, cmd.replace('-', '_'))({'format': format}, **op)
if (format == 'json'):
write_response = json.dumps(rpc_reply, indent=1)
else:
write_response = rpc_reply.text
except Exception as exception:
ret['message'] = 'Execution failed due to "{0}"'.format(exception)
ret['out'] = False
if (dest is not None):
with fopen(dest, 'w') as fp:
fp.write(write_response)
return ret
| [
"def",
"rpc",
"(",
"cmd",
"=",
"None",
",",
"dest",
"=",
"None",
",",
"format",
"=",
"'xml'",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"conn",
"=",
"__proxy__",
"[",
"'junos.conn'",
"]",
"(",
")",
"ret",
"=",
"dict",
"(",
")",
"ret",
"[... | executes the given rpc . | train | false |
4,243 | def addValueToOutput(depth, keyInput, output, value):
depthStart = (' ' * depth)
output.write(('%s%s:' % (depthStart, keyInput)))
if (value.__class__ == dict):
output.write('\n')
keys = value.keys()
keys.sort()
for key in keys:
addValueToOutput((depth + 1), key, output, value[key])
return
if (value.__class__ == list):
output.write('\n')
for (elementIndex, element) in enumerate(value):
addValueToOutput((depth + 1), elementIndex, output, element)
return
output.write((' %s\n' % value))
| [
"def",
"addValueToOutput",
"(",
"depth",
",",
"keyInput",
",",
"output",
",",
"value",
")",
":",
"depthStart",
"=",
"(",
"' '",
"*",
"depth",
")",
"output",
".",
"write",
"(",
"(",
"'%s%s:'",
"%",
"(",
"depthStart",
",",
"keyInput",
")",
")",
")",
"... | add value to the output . | train | false |
4,244 | def assign(obj, **kwargs):
obj.__dict__.update(kwargs)
| [
"def",
"assign",
"(",
"obj",
",",
"**",
"kwargs",
")",
":",
"obj",
".",
"__dict__",
".",
"update",
"(",
"kwargs",
")"
] | assign a single sysctl parameter for this minion cli example: . | train | false |
4,245 | @pytest.mark.network
def test_editables_flag(script, data):
script.pip('install', '-f', data.find_links, '--no-index', 'simple==1.0')
result = script.pip('install', '-e', 'git+https://github.com/pypa/pip-test-package.git#egg=pip-test-package')
result = script.pip('list', '--editable', '--format=legacy')
assert ('simple (1.0)' not in result.stdout), str(result)
assert (os.path.join('src', 'pip-test-package') in result.stdout), str(result)
| [
"@",
"pytest",
".",
"mark",
".",
"network",
"def",
"test_editables_flag",
"(",
"script",
",",
"data",
")",
":",
"script",
".",
"pip",
"(",
"'install'",
",",
"'-f'",
",",
"data",
".",
"find_links",
",",
"'--no-index'",
",",
"'simple==1.0'",
")",
"result",
... | test the behavior of --editables flag in the list command . | train | false |
4,246 | def gis_opacity():
T = current.T
OPACITY = T('Opacity')
return S3ReusableField('opacity', 'double', default=1.0, label=OPACITY, requires=IS_FLOAT_IN_RANGE(0, 1), widget=S3SliderWidget(0.01, 'float'), comment=DIV(_class='tooltip', _title=('%s|%s' % (OPACITY, T('Left-side is fully transparent (0), right-side is opaque (1.0).')))))
| [
"def",
"gis_opacity",
"(",
")",
":",
"T",
"=",
"current",
".",
"T",
"OPACITY",
"=",
"T",
"(",
"'Opacity'",
")",
"return",
"S3ReusableField",
"(",
"'opacity'",
",",
"'double'",
",",
"default",
"=",
"1.0",
",",
"label",
"=",
"OPACITY",
",",
"requires",
"... | used by gis_style . | train | false |
4,247 | def disable_source(name):
return _change_source_state(name, 'disable')
| [
"def",
"disable_source",
"(",
"name",
")",
":",
"return",
"_change_source_state",
"(",
"name",
",",
"'disable'",
")"
] | instructs chocolatey to disable a source . | train | false |
4,249 | @handle_response_format
@treeio_login_required
def folder_delete(request, folder_id, response_format='html'):
folder = get_object_or_404(Folder, pk=folder_id)
if (not request.user.profile.has_permission(folder, mode='w')):
return user_denied(request, message="You don't have access to this Folder")
if request.POST:
if ('delete' in request.POST):
if ('trash' in request.POST):
folder.trash = True
folder.save()
else:
folder.delete()
return HttpResponseRedirect(reverse('document_index'))
elif ('cancel' in request.POST):
return HttpResponseRedirect(reverse('documents_folder_view', args=[folder.id]))
query = ((Q(object_type='treeio.documents.models.Document') | Q(object_type='treeio.documents.models.File')) | Q(object_type='treeio.documents.models.WebLink'))
query = (query & ((Q(document__folder=folder) | Q(file__folder=folder)) | Q(weblink__folder=folder)))
if request.GET:
query = _get_filter_query(request.GET)
objects = Object.filter_by_request(request, Object.objects.filter(query))
else:
objects = Object.filter_by_request(request, Object.objects.filter(query))
context = _get_default_context(request)
context.update({'folder': folder, 'objects': objects})
return render_to_response('documents/folder_delete', context, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"handle_response_format",
"@",
"treeio_login_required",
"def",
"folder_delete",
"(",
"request",
",",
"folder_id",
",",
"response_format",
"=",
"'html'",
")",
":",
"folder",
"=",
"get_object_or_404",
"(",
"Folder",
",",
"pk",
"=",
"folder_id",
")",
"if",
"("... | type delete . | train | false |
4,251 | def _docs():
dev = _get_import_dir()[1]
if (not dev):
warnings.warn("Docstring test imports Vispy from Vispy's installation. It is recommended to setup Vispy using 'python setup.py develop' so that the latest sources are used automatically")
try:
from ..util.tests import test_docstring_parameters
print('Running docstring test...')
test_docstring_parameters.test_docstring_parameters()
except AssertionError as docstring_violations:
raise RuntimeError(docstring_violations)
| [
"def",
"_docs",
"(",
")",
":",
"dev",
"=",
"_get_import_dir",
"(",
")",
"[",
"1",
"]",
"if",
"(",
"not",
"dev",
")",
":",
"warnings",
".",
"warn",
"(",
"\"Docstring test imports Vispy from Vispy's installation. It is recommended to setup Vispy using 'python setup.py dev... | test docstring paramters using vispy/utils/tests/test_docstring_parameters . | train | false |
4,252 | @contextmanager
def lock_file(filename, timeout=10, append=False, unlink=True):
flags = (os.O_CREAT | os.O_RDWR)
if append:
flags |= os.O_APPEND
mode = 'a+'
else:
mode = 'r+'
fd = os.open(filename, flags)
file_obj = os.fdopen(fd, mode)
try:
with LockTimeout(timeout, filename):
while True:
try:
fcntl.flock(fd, (fcntl.LOCK_EX | fcntl.LOCK_NB))
break
except IOError as err:
if (err.errno != errno.EAGAIN):
raise
sleep(0.01)
(yield file_obj)
finally:
try:
file_obj.close()
except UnboundLocalError:
pass
if unlink:
os.unlink(filename)
| [
"@",
"contextmanager",
"def",
"lock_file",
"(",
"filename",
",",
"timeout",
"=",
"10",
",",
"append",
"=",
"False",
",",
"unlink",
"=",
"True",
")",
":",
"flags",
"=",
"(",
"os",
".",
"O_CREAT",
"|",
"os",
".",
"O_RDWR",
")",
"if",
"append",
":",
"... | context manager that acquires a lock on a file . | train | false |
4,253 | def settings(request):
settings = debug.get_safe_settings()
sorted_settings = [{'key': key, 'value': settings[key]} for key in sorted(settings.keys())]
return render_to_response('kadmin/settings.html', {'pythonpath': sys.path, 'settings': sorted_settings, 'title': 'Settings'}, RequestContext(request, {}))
| [
"def",
"settings",
"(",
"request",
")",
":",
"settings",
"=",
"debug",
".",
"get_safe_settings",
"(",
")",
"sorted_settings",
"=",
"[",
"{",
"'key'",
":",
"key",
",",
"'value'",
":",
"settings",
"[",
"key",
"]",
"}",
"for",
"key",
"in",
"sorted",
"(",
... | nest context managers and/or override env variables . | train | false |
4,254 | def occurrence(request, event_id, template_name='schedule/occurrence.html', *args, **kwargs):
(event, occurrence) = get_occurrence(event_id, *args, **kwargs)
back_url = request.META.get('HTTP_REFERER', None)
return render_to_response(template_name, {'event': event, 'occurrence': occurrence, 'back_url': back_url}, context_instance=RequestContext(request))
| [
"def",
"occurrence",
"(",
"request",
",",
"event_id",
",",
"template_name",
"=",
"'schedule/occurrence.html'",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"(",
"event",
",",
"occurrence",
")",
"=",
"get_occurrence",
"(",
"event_id",
",",
"*",
"args",
... | this view is used to display an occurrence . | train | false |
4,256 | def get_converter(from_unit, to_unit):
try:
scale = from_unit._to(to_unit)
except UnitsError:
return from_unit._apply_equivalencies(from_unit, to_unit, get_current_unit_registry().equivalencies)
if (scale == 1.0):
return None
else:
return (lambda val: (scale * val))
| [
"def",
"get_converter",
"(",
"from_unit",
",",
"to_unit",
")",
":",
"try",
":",
"scale",
"=",
"from_unit",
".",
"_to",
"(",
"to_unit",
")",
"except",
"UnitsError",
":",
"return",
"from_unit",
".",
"_apply_equivalencies",
"(",
"from_unit",
",",
"to_unit",
","... | create a new converter for the given arguments or raise exception if the converter does not exist . | train | false |
4,257 | def raises_Invalid(function):
def call_and_assert(*args, **kwargs):
nose.tools.assert_raises(df.Invalid, function, *args, **kwargs)
return call_and_assert
| [
"def",
"raises_Invalid",
"(",
"function",
")",
":",
"def",
"call_and_assert",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"nose",
".",
"tools",
".",
"assert_raises",
"(",
"df",
".",
"Invalid",
",",
"function",
",",
"*",
"args",
",",
"**",
"kwargs"... | a decorator that asserts that the decorated function raises dictization_functions . | train | false |
4,258 | def parse_p2g(lines):
description = next(lines).strip()
G = networkx.MultiDiGraph(name=description, selfloops=True)
(nnodes, nedges) = map(int, next(lines).split())
nodelabel = {}
nbrs = {}
for i in range(nnodes):
n = next(lines).strip()
nodelabel[i] = n
G.add_node(n)
nbrs[n] = map(int, next(lines).split())
for n in G:
for nbr in nbrs[n]:
G.add_edge(n, nodelabel[nbr])
return G
| [
"def",
"parse_p2g",
"(",
"lines",
")",
":",
"description",
"=",
"next",
"(",
"lines",
")",
".",
"strip",
"(",
")",
"G",
"=",
"networkx",
".",
"MultiDiGraph",
"(",
"name",
"=",
"description",
",",
"selfloops",
"=",
"True",
")",
"(",
"nnodes",
",",
"ne... | parse p2g format graph from string or iterable . | train | false |
4,260 | def get_cloud_init_mime(cloud_init):
if isinstance(cloud_init, six.string_types):
cloud_init = json.loads(cloud_init)
_cloud_init = email.mime.multipart.MIMEMultipart()
if ('boothooks' in cloud_init):
for (script_name, script) in six.iteritems(cloud_init['boothooks']):
_script = email.mime.text.MIMEText(script, 'cloud-boothook')
_cloud_init.attach(_script)
if ('scripts' in cloud_init):
for (script_name, script) in six.iteritems(cloud_init['scripts']):
_script = email.mime.text.MIMEText(script, 'x-shellscript')
_cloud_init.attach(_script)
if ('cloud-config' in cloud_init):
cloud_config = cloud_init['cloud-config']
_cloud_config = email.mime.text.MIMEText(_safe_dump(cloud_config), 'cloud-config')
_cloud_init.attach(_cloud_config)
return _cloud_init.as_string()
| [
"def",
"get_cloud_init_mime",
"(",
"cloud_init",
")",
":",
"if",
"isinstance",
"(",
"cloud_init",
",",
"six",
".",
"string_types",
")",
":",
"cloud_init",
"=",
"json",
".",
"loads",
"(",
"cloud_init",
")",
"_cloud_init",
"=",
"email",
".",
"mime",
".",
"mu... | get a mime multipart encoded string from a cloud-init dict . | train | false |
4,261 | @pytest.mark.django_db
def test_reject_suggestion_with_comment(client, request_users):
Comment = get_comment_model()
unit = Unit.objects.filter(suggestion__state='pending', state=UNTRANSLATED)[0]
sugg = Suggestion.objects.filter(unit=unit, state='pending')[0]
comment = 'This is a comment!'
user = request_users['user']
if (user.username != 'nobody'):
client.login(username=user.username, password=request_users['password'])
url = ('/xhr/units/%d/suggestions/%d/' % (unit.id, sugg.id))
response = client.delete(url, ('comment=%s' % comment), HTTP_X_REQUESTED_WITH='XMLHttpRequest')
can_reject = (check_permission('review', response.wsgi_request) or (sugg.user.id == user.id))
if can_reject:
assert (response.status_code == 200)
rejected_suggestion = Suggestion.objects.get(id=sugg.id)
assert (rejected_suggestion.state == 'rejected')
assert (Comment.objects.for_model(rejected_suggestion).get().comment == comment)
else:
assert (response.status_code == 403)
| [
"@",
"pytest",
".",
"mark",
".",
"django_db",
"def",
"test_reject_suggestion_with_comment",
"(",
"client",
",",
"request_users",
")",
":",
"Comment",
"=",
"get_comment_model",
"(",
")",
"unit",
"=",
"Unit",
".",
"objects",
".",
"filter",
"(",
"suggestion__state"... | tests suggestion can be rejected with a comment . | train | false |
4,262 | def init_test(options, testdir):
locals_dict = locals().copy()
globals_dict = globals().copy()
locals_dict['testdir'] = testdir
job = setup_job(options=options)
locals_dict['job'] = job
test_name = os.path.split(testdir)[(-1)]
outputdir = os.path.join(job.resultdir, test_name)
try:
os.makedirs(outputdir)
except OSError:
pass
locals_dict['outputdir'] = outputdir
sys.path.insert(0, testdir)
client_test = None
try:
import_stmt = ('import %s' % test_name)
init_stmt = ('auto_test = %s.%s(job, testdir, outputdir)' % (test_name, test_name))
exec ((import_stmt + '\n') + init_stmt) in locals_dict, globals_dict
client_test = globals_dict['auto_test']
except ImportError as e:
if re.search(test_name, str(e)):
pass
else:
logging.error(('%s import error: %s. Skipping %s' % (test_name, e, test_name)))
except Exception as e:
logging.error('%s: %s', test_name, e)
finally:
sys.path.pop(0)
return client_test
| [
"def",
"init_test",
"(",
"options",
",",
"testdir",
")",
":",
"locals_dict",
"=",
"locals",
"(",
")",
".",
"copy",
"(",
")",
"globals_dict",
"=",
"globals",
"(",
")",
".",
"copy",
"(",
")",
"locals_dict",
"[",
"'testdir'",
"]",
"=",
"testdir",
"job",
... | instantiate a client test object from a given test directory . | train | false |
4,264 | def _retrieve_dummy(job_path):
pass
| [
"def",
"_retrieve_dummy",
"(",
"job_path",
")",
":",
"pass"
] | dummy function for retrieving host and logs . | train | false |
4,266 | def validate_kwargs(fname, kwargs, compat_args):
kwds = kwargs.copy()
_check_for_invalid_keys(fname, kwargs, compat_args)
_check_for_default_values(fname, kwds, compat_args)
| [
"def",
"validate_kwargs",
"(",
"fname",
",",
"kwargs",
",",
"compat_args",
")",
":",
"kwds",
"=",
"kwargs",
".",
"copy",
"(",
")",
"_check_for_invalid_keys",
"(",
"fname",
",",
"kwargs",
",",
"compat_args",
")",
"_check_for_default_values",
"(",
"fname",
",",
... | checks whether parameters passed to the **kwargs argument in a function fname are valid parameters as specified in *compat_args and whether or not they are set to their default values . | train | true |
4,267 | def _get_offset_param(params):
offset = params.pop('offset', 0)
return utils.validate_integer(offset, 'offset', 0, constants.DB_MAX_INT)
| [
"def",
"_get_offset_param",
"(",
"params",
")",
":",
"offset",
"=",
"params",
".",
"pop",
"(",
"'offset'",
",",
"0",
")",
"return",
"utils",
".",
"validate_integer",
"(",
"offset",
",",
"'offset'",
",",
"0",
",",
"constants",
".",
"DB_MAX_INT",
")"
] | extract offset id from requests dictionary or fail . | train | false |
4,268 | def evaluate_deltas(e):
accepted_functions = (Add,)
if isinstance(e, accepted_functions):
return e.func(*[evaluate_deltas(arg) for arg in e.args])
elif isinstance(e, Mul):
deltas = []
indices = {}
for i in e.args:
for s in i.free_symbols:
if (s in indices):
indices[s] += 1
else:
indices[s] = 0
if isinstance(i, KroneckerDelta):
deltas.append(i)
for d in deltas:
if indices[d.killable_index]:
e = e.subs(d.killable_index, d.preferred_index)
if (len(deltas) > 1):
return evaluate_deltas(e)
elif (indices[d.preferred_index] and d.indices_contain_equal_information):
e = e.subs(d.preferred_index, d.killable_index)
if (len(deltas) > 1):
return evaluate_deltas(e)
else:
pass
return e
else:
return e
| [
"def",
"evaluate_deltas",
"(",
"e",
")",
":",
"accepted_functions",
"=",
"(",
"Add",
",",
")",
"if",
"isinstance",
"(",
"e",
",",
"accepted_functions",
")",
":",
"return",
"e",
".",
"func",
"(",
"*",
"[",
"evaluate_deltas",
"(",
"arg",
")",
"for",
"arg... | we evaluate kroneckerdelta symbols in the expression assuming einstein summation . | train | false |
4,269 | def get_ipython_package_dir():
ipdir = os.path.dirname(IPython.__file__)
return py3compat.cast_unicode(ipdir, fs_encoding)
| [
"def",
"get_ipython_package_dir",
"(",
")",
":",
"ipdir",
"=",
"os",
".",
"path",
".",
"dirname",
"(",
"IPython",
".",
"__file__",
")",
"return",
"py3compat",
".",
"cast_unicode",
"(",
"ipdir",
",",
"fs_encoding",
")"
] | get the base directory where ipython itself is installed . | train | true |
4,271 | @not_implemented_for('directed')
def generalized_degree(G, nodes=None):
if (nodes in G):
return next(_triangles_and_degree_iter(G, nodes))[3]
return {v: gd for (v, d, t, gd) in _triangles_and_degree_iter(G, nodes)}
| [
"@",
"not_implemented_for",
"(",
"'directed'",
")",
"def",
"generalized_degree",
"(",
"G",
",",
"nodes",
"=",
"None",
")",
":",
"if",
"(",
"nodes",
"in",
"G",
")",
":",
"return",
"next",
"(",
"_triangles_and_degree_iter",
"(",
"G",
",",
"nodes",
")",
")"... | compute the generalized degree for nodes . | train | false |
4,272 | def jail_path_configured():
try:
jc = JailsConfiguration.objects.latest('id')
except JailsConfiguration.DoesNotExist:
jc = None
return (jc and jc.jc_path and os.path.exists(jc.jc_path))
| [
"def",
"jail_path_configured",
"(",
")",
":",
"try",
":",
"jc",
"=",
"JailsConfiguration",
".",
"objects",
".",
"latest",
"(",
"'id'",
")",
"except",
"JailsConfiguration",
".",
"DoesNotExist",
":",
"jc",
"=",
"None",
"return",
"(",
"jc",
"and",
"jc",
".",
... | check if there is the jail system is configured by looking at the jailsconfiguration model and jc_path field :returns: boolean . | train | false |
4,273 | @webob.dec.wsgify
@util.check_accept('application/json')
def list_usages(req):
context = req.environ['placement.context']
uuid = util.wsgi_path_item(req.environ, 'uuid')
try:
resource_provider = objects.ResourceProvider.get_by_uuid(context, uuid)
except exception.NotFound as exc:
raise webob.exc.HTTPNotFound((_('No resource provider with uuid %(uuid)s found: %(error)s') % {'uuid': uuid, 'error': exc}), json_formatter=util.json_error_formatter)
usage = objects.UsageList.get_all_by_resource_provider_uuid(context, uuid)
response = req.response
response.body = encodeutils.to_utf8(jsonutils.dumps(_serialize_usages(resource_provider, usage)))
req.response.content_type = 'application/json'
return req.response
| [
"@",
"webob",
".",
"dec",
".",
"wsgify",
"@",
"util",
".",
"check_accept",
"(",
"'application/json'",
")",
"def",
"list_usages",
"(",
"req",
")",
":",
"context",
"=",
"req",
".",
"environ",
"[",
"'placement.context'",
"]",
"uuid",
"=",
"util",
".",
"wsgi... | get a dictionary of resource provider usage by resource class . | train | false |
4,274 | def skipUnless(condition, reason):
if (not condition):
return skip(reason)
return _id
| [
"def",
"skipUnless",
"(",
"condition",
",",
"reason",
")",
":",
"if",
"(",
"not",
"condition",
")",
":",
"return",
"skip",
"(",
"reason",
")",
"return",
"_id"
] | skip a test unless the condition is true . | train | false |
4,275 | def numpy_cupy_array_almost_equal_nulp(nulp=1, name='xp', type_check=True, accept_error=False):
def check_func(x, y):
array.assert_array_almost_equal_nulp(x, y, nulp)
return _make_decorator(check_func, name, type_check, accept_error)
| [
"def",
"numpy_cupy_array_almost_equal_nulp",
"(",
"nulp",
"=",
"1",
",",
"name",
"=",
"'xp'",
",",
"type_check",
"=",
"True",
",",
"accept_error",
"=",
"False",
")",
":",
"def",
"check_func",
"(",
"x",
",",
"y",
")",
":",
"array",
".",
"assert_array_almost... | decorator that checks results of numpy and cupy are equal w . | train | false |
4,276 | def setlocale(category, locale=None):
if (locale and (not isinstance(locale, _builtin_str))):
locale = normalize(_build_localename(locale))
return _setlocale(category, locale)
| [
"def",
"setlocale",
"(",
"category",
",",
"locale",
"=",
"None",
")",
":",
"if",
"(",
"locale",
"and",
"(",
"not",
"isinstance",
"(",
"locale",
",",
"_builtin_str",
")",
")",
")",
":",
"locale",
"=",
"normalize",
"(",
"_build_localename",
"(",
"locale",
... | set the locale for the given category . | train | false |
4,277 | def verify_signed_data(token, data):
if data.startswith(MAC_MARKER):
try:
data = data[len(MAC_MARKER):]
mac_data = json.loads(base64.b64decode(data))
mac = compute_mac(token, mac_data['serialized_data'])
if (mac != mac_data['mac']):
raise InvalidMacError(('invalid MAC; expect=%s, actual=%s' % (mac_data['mac'], mac)))
return json.loads(mac_data['serialized_data'])
except:
raise InvalidMacError('invalid MAC; data appeared to be corrupted')
else:
return data
| [
"def",
"verify_signed_data",
"(",
"token",
",",
"data",
")",
":",
"if",
"data",
".",
"startswith",
"(",
"MAC_MARKER",
")",
":",
"try",
":",
"data",
"=",
"data",
"[",
"len",
"(",
"MAC_MARKER",
")",
":",
"]",
"mac_data",
"=",
"json",
".",
"loads",
"(",... | verify data integrity by ensuring mac is valid . | train | false |
4,278 | @require_POST
@login_required
def edit_priority(request, pk):
source = get_object_or_404(Source, pk=pk)
if (not can_edit_priority(request.user, source.subproject.project)):
raise PermissionDenied()
form = PriorityForm(request.POST)
if form.is_valid():
source.priority = form.cleaned_data['priority']
source.save()
else:
messages.error(request, _('Failed to change a priority!'))
return redirect(request.POST.get('next', source.get_absolute_url()))
| [
"@",
"require_POST",
"@",
"login_required",
"def",
"edit_priority",
"(",
"request",
",",
"pk",
")",
":",
"source",
"=",
"get_object_or_404",
"(",
"Source",
",",
"pk",
"=",
"pk",
")",
"if",
"(",
"not",
"can_edit_priority",
"(",
"request",
".",
"user",
",",
... | change source string priority . | train | false |
4,279 | @addon_view
@non_atomic_requests
def sources_series(request, addon, group, start, end, format):
date_range = check_series_params_or_404(group, start, end, format)
check_stats_permission(request, addon)
series = get_series(DownloadCount, source='sources', addon=addon.id, date__range=date_range)
if (format == 'csv'):
(series, fields) = csv_fields(series)
return render_csv(request, addon, series, (['date', 'count'] + list(fields)))
elif (format == 'json'):
return render_json(request, addon, series)
| [
"@",
"addon_view",
"@",
"non_atomic_requests",
"def",
"sources_series",
"(",
"request",
",",
"addon",
",",
"group",
",",
"start",
",",
"end",
",",
"format",
")",
":",
"date_range",
"=",
"check_series_params_or_404",
"(",
"group",
",",
"start",
",",
"end",
",... | generate download source breakdown . | train | false |
4,280 | def bdist_wininst_arch(pyver, arch):
if os.path.exists('build'):
shutil.rmtree('build')
_bdist_wininst(pyver, SITECFG[arch])
| [
"def",
"bdist_wininst_arch",
"(",
"pyver",
",",
"arch",
")",
":",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"'build'",
")",
":",
"shutil",
".",
"rmtree",
"(",
"'build'",
")",
"_bdist_wininst",
"(",
"pyver",
",",
"SITECFG",
"[",
"arch",
"]",
")"
] | arch specific wininst build . | train | false |
4,283 | def _get_record(xapi, rectype, uuid):
return getattr(xapi, rectype).get_record(uuid)
| [
"def",
"_get_record",
"(",
"xapi",
",",
"rectype",
",",
"uuid",
")",
":",
"return",
"getattr",
"(",
"xapi",
",",
"rectype",
")",
".",
"get_record",
"(",
"uuid",
")"
] | gets the record object for a given fqdn . | train | false |
4,285 | def _report_not_exist(source_dir, path, blade):
depender = _find_dir_depender(source_dir, blade)
if depender:
console.error_exit(('//%s not found, required by %s, exit...' % (path, depender)))
else:
console.error_exit(('//%s not found, exit...' % path))
| [
"def",
"_report_not_exist",
"(",
"source_dir",
",",
"path",
",",
"blade",
")",
":",
"depender",
"=",
"_find_dir_depender",
"(",
"source_dir",
",",
"blade",
")",
"if",
"depender",
":",
"console",
".",
"error_exit",
"(",
"(",
"'//%s not found, required by %s, exit..... | report dir or build file does not exist . | train | false |
4,286 | def setup_workers(num_cpus, outdir, server_socket, verbose=True, error_profile=None):
DENOISE_WORKER = 'denoiser_worker.py'
workers = []
client_sockets = []
tmpname = ''.join(sample(list(lowercase), 8))
(host, port) = server_socket.getsockname()
for i in range(num_cpus):
name = (outdir + ('/%sworker%d' % (tmpname, i)))
workers.append(name)
cmd = ('%s -f %s -s %s -p %s' % (DENOISE_WORKER, name, host, port))
if verbose:
cmd += ' -v'
if error_profile:
cmd += (' -e %s' % error_profile)
submit_jobs([cmd], tmpname)
(client_socket, client_address) = server_socket.accept()
client_sockets.append((client_socket, client_address))
return (workers, client_sockets)
| [
"def",
"setup_workers",
"(",
"num_cpus",
",",
"outdir",
",",
"server_socket",
",",
"verbose",
"=",
"True",
",",
"error_profile",
"=",
"None",
")",
":",
"DENOISE_WORKER",
"=",
"'denoiser_worker.py'",
"workers",
"=",
"[",
"]",
"client_sockets",
"=",
"[",
"]",
... | start workers waiting for data . | train | false |
4,287 | def _paint_path(fill, stroke):
if stroke:
if fill:
return Op.fill_stroke
else:
return Op.stroke
elif fill:
return Op.fill
else:
return Op.endpath
| [
"def",
"_paint_path",
"(",
"fill",
",",
"stroke",
")",
":",
"if",
"stroke",
":",
"if",
"fill",
":",
"return",
"Op",
".",
"fill_stroke",
"else",
":",
"return",
"Op",
".",
"stroke",
"elif",
"fill",
":",
"return",
"Op",
".",
"fill",
"else",
":",
"return... | return the pdf operator to paint a path in the following way: fill: fill the path with the fill color stroke: stroke the outline of the path with the line color . | train | false |
4,288 | def getIndex(form, pos='noun'):
def trySubstitutions(trySubstitutions, form, substitutions, lookup=1, dictionary=dictionaryFor(pos)):
if (lookup and dictionary.has_key(form)):
return dictionary[form]
elif substitutions:
(old, new) = substitutions[0]
substitute = (string.replace(form, old, new) and (substitute != form))
if (substitute and dictionary.has_key(substitute)):
return dictionary[substitute]
return (trySubstitutions(trySubstitutions, form, substitutions[1:], lookup=0) or (substitute and trySubstitutions(trySubstitutions, substitute, substitutions[1:])))
return trySubstitutions(returnMatch, form, GET_INDEX_SUBSTITUTIONS)
| [
"def",
"getIndex",
"(",
"form",
",",
"pos",
"=",
"'noun'",
")",
":",
"def",
"trySubstitutions",
"(",
"trySubstitutions",
",",
"form",
",",
"substitutions",
",",
"lookup",
"=",
"1",
",",
"dictionary",
"=",
"dictionaryFor",
"(",
"pos",
")",
")",
":",
"if",... | search for _form_ in the index file corresponding to _pos_ . | train | false |
4,289 | def highlight_string(source, unit):
if (unit is None):
return []
highlights = []
for check in CHECKS:
if (not CHECKS[check].target):
continue
highlights += CHECKS[check].check_highlight(source, unit)
highlights.sort(key=(lambda x: x[0]))
for hl_idx in range(0, len(highlights)):
if (hl_idx >= len(highlights)):
break
elref = highlights[hl_idx]
for hl_idx_next in range((hl_idx + 1), len(highlights)):
if (hl_idx_next >= len(highlights)):
break
eltest = highlights[hl_idx_next]
if ((eltest[0] >= elref[0]) and (eltest[0] < elref[1])):
highlights.pop(hl_idx_next)
elif (eltest[0] > elref[1]):
break
return highlights
| [
"def",
"highlight_string",
"(",
"source",
",",
"unit",
")",
":",
"if",
"(",
"unit",
"is",
"None",
")",
":",
"return",
"[",
"]",
"highlights",
"=",
"[",
"]",
"for",
"check",
"in",
"CHECKS",
":",
"if",
"(",
"not",
"CHECKS",
"[",
"check",
"]",
".",
... | returns highlights for a string . | train | false |
4,290 | def quote_sheetname(sheetname):
if ((not sheetname.isalnum()) and (not sheetname.startswith("'"))):
sheetname = sheetname.replace("'", "''")
sheetname = ("'%s'" % sheetname)
return sheetname
| [
"def",
"quote_sheetname",
"(",
"sheetname",
")",
":",
"if",
"(",
"(",
"not",
"sheetname",
".",
"isalnum",
"(",
")",
")",
"and",
"(",
"not",
"sheetname",
".",
"startswith",
"(",
"\"'\"",
")",
")",
")",
":",
"sheetname",
"=",
"sheetname",
".",
"replace",... | convert a worksheet name to a quoted name if it contains spaces or special characters . | train | false |
4,291 | def colormaps():
return sorted(cm.cmap_d)
| [
"def",
"colormaps",
"(",
")",
":",
"return",
"sorted",
"(",
"cm",
".",
"cmap_d",
")"
] | matplotlib provides the following colormaps . | train | false |
4,292 | def obj_to_ref(obj):
try:
ref = ('%s:%s' % (obj.__module__, get_callable_name(obj)))
obj2 = ref_to_obj(ref)
if (obj != obj2):
raise ValueError
except Exception:
raise ValueError(('Cannot determine the reference to %r' % obj))
return ref
| [
"def",
"obj_to_ref",
"(",
"obj",
")",
":",
"try",
":",
"ref",
"=",
"(",
"'%s:%s'",
"%",
"(",
"obj",
".",
"__module__",
",",
"get_callable_name",
"(",
"obj",
")",
")",
")",
"obj2",
"=",
"ref_to_obj",
"(",
"ref",
")",
"if",
"(",
"obj",
"!=",
"obj2",
... | returns the path to the given object . | train | false |
4,294 | def _model_to_fit_params(model):
fitparam_indices = list(range(len(model.param_names)))
if (any(model.fixed.values()) or any(model.tied.values())):
params = list(model.parameters)
param_metrics = model._param_metrics
for (idx, name) in list(enumerate(model.param_names))[::(-1)]:
if (model.fixed[name] or model.tied[name]):
slice_ = param_metrics[name][u'slice']
del params[slice_]
del fitparam_indices[idx]
return (np.array(params), fitparam_indices)
else:
return (model.parameters, fitparam_indices)
| [
"def",
"_model_to_fit_params",
"(",
"model",
")",
":",
"fitparam_indices",
"=",
"list",
"(",
"range",
"(",
"len",
"(",
"model",
".",
"param_names",
")",
")",
")",
"if",
"(",
"any",
"(",
"model",
".",
"fixed",
".",
"values",
"(",
")",
")",
"or",
"any"... | convert a model instances parameter array to an array that can be used with a fitter that doesnt natively support fixed or tied parameters . | train | false |
4,296 | def test_replace_update_column_via_setitem():
a = ([1, 2] * u.m)
b = [3, 4]
t = table.QTable([a, b], names=['a', 'b'])
assert isinstance(t['a'], u.Quantity)
ta = t['a']
t['a'] = (5 * u.m)
assert np.all((t['a'] == ([5, 5] * u.m)))
assert (t['a'] is ta)
t['a'] = [5, 6]
assert np.all((t['a'] == [5, 6]))
assert isinstance(t['a'], table.Column)
assert (t['a'] is not ta)
| [
"def",
"test_replace_update_column_via_setitem",
"(",
")",
":",
"a",
"=",
"(",
"[",
"1",
",",
"2",
"]",
"*",
"u",
".",
"m",
")",
"b",
"=",
"[",
"3",
",",
"4",
"]",
"t",
"=",
"table",
".",
"QTable",
"(",
"[",
"a",
",",
"b",
"]",
",",
"names",
... | test table update like t[a] = value . | train | false |
4,297 | def floored_twelfth_of_a_360_day_year(date):
timetuple = date.timetuple()
year = timetuple.tm_year
day_of_year = timetuple.tm_yday
month0 = floor(((day_of_year / 360) * 12))
return ((((year - start_year) * 12) + month0) - start_month_0_indexed)
| [
"def",
"floored_twelfth_of_a_360_day_year",
"(",
"date",
")",
":",
"timetuple",
"=",
"date",
".",
"timetuple",
"(",
")",
"year",
"=",
"timetuple",
".",
"tm_year",
"day_of_year",
"=",
"timetuple",
".",
"tm_yday",
"month0",
"=",
"floor",
"(",
"(",
"(",
"day_of... | this function converts a date to a month number by flooring to the nearest 12th of a 360 day year . | train | false |
4,298 | @cache_permission
def can_upload_dictionary(user, project):
return check_permission(user, project, 'trans.upload_dictionary')
| [
"@",
"cache_permission",
"def",
"can_upload_dictionary",
"(",
"user",
",",
"project",
")",
":",
"return",
"check_permission",
"(",
"user",
",",
"project",
",",
"'trans.upload_dictionary'",
")"
] | checks whether user can upload dictionary for given project . | train | false |
4,299 | def GetDebugger():
try:
import pywin.debugger
return pywin.debugger
except ImportError:
return None
| [
"def",
"GetDebugger",
"(",
")",
":",
"try",
":",
"import",
"pywin",
".",
"debugger",
"return",
"pywin",
".",
"debugger",
"except",
"ImportError",
":",
"return",
"None"
] | get the default python debugger . | train | false |
4,300 | def apply_trans(trans, pts, move=True):
if isinstance(trans, dict):
trans = trans['trans']
trans = np.asarray(trans)
pts = np.asarray(pts)
if (pts.size == 0):
return pts.copy()
out_pts = np.dot(pts, trans[:3, :3].T)
if (move is True):
transl = trans[:3, 3]
if np.any((transl != 0)):
out_pts += transl
return out_pts
| [
"def",
"apply_trans",
"(",
"trans",
",",
"pts",
",",
"move",
"=",
"True",
")",
":",
"if",
"isinstance",
"(",
"trans",
",",
"dict",
")",
":",
"trans",
"=",
"trans",
"[",
"'trans'",
"]",
"trans",
"=",
"np",
".",
"asarray",
"(",
"trans",
")",
"pts",
... | apply a transform matrix to an array of points . | train | false |
4,301 | def pportOut(data):
global dataReg
port.DlPortWritePortUchar(baseAddress, data)
dataReg = data
| [
"def",
"pportOut",
"(",
"data",
")",
":",
"global",
"dataReg",
"port",
".",
"DlPortWritePortUchar",
"(",
"baseAddress",
",",
"data",
")",
"dataReg",
"=",
"data"
] | data output function . | train | false |
4,302 | def list_frameworks():
sys.stdout.write(('Testable frameworks: %s\n\nNote that membership in this list means the framework can be tested with\nPyMongo, not necessarily that it is officially supported.\n' % ', '.join(sorted(FRAMEWORKS))))
| [
"def",
"list_frameworks",
"(",
")",
":",
"sys",
".",
"stdout",
".",
"write",
"(",
"(",
"'Testable frameworks: %s\\n\\nNote that membership in this list means the framework can be tested with\\nPyMongo, not necessarily that it is officially supported.\\n'",
"%",
"', '",
".",
"join",
... | tell the user what framework names are valid . | train | false |
4,304 | def pr_remove_from_role(role_id, pe_id):
atable = current.s3db.pr_affiliation
query = ((atable.role_id == role_id) & (atable.pe_id == pe_id))
affiliation = current.db(query).select(atable.id, limitby=(0, 1)).first()
if (affiliation is not None):
deleted_fk = {'role_id': role_id, 'pe_id': pe_id}
data = {'deleted': True, 'role_id': None, 'pe_id': None, 'deleted_fk': json.dumps(deleted_fk)}
affiliation.update_record(**data)
pr_rebuild_path(pe_id, clear=True)
return
| [
"def",
"pr_remove_from_role",
"(",
"role_id",
",",
"pe_id",
")",
":",
"atable",
"=",
"current",
".",
"s3db",
".",
"pr_affiliation",
"query",
"=",
"(",
"(",
"atable",
".",
"role_id",
"==",
"role_id",
")",
"&",
"(",
"atable",
".",
"pe_id",
"==",
"pe_id",
... | back-end method to remove a person entity from a role . | train | false |
4,307 | def sha_to_hex(sha):
hexsha = binascii.hexlify(sha)
assert (len(hexsha) == 40), ('Incorrect length of sha1 string: %d' % hexsha)
return hexsha
| [
"def",
"sha_to_hex",
"(",
"sha",
")",
":",
"hexsha",
"=",
"binascii",
".",
"hexlify",
"(",
"sha",
")",
"assert",
"(",
"len",
"(",
"hexsha",
")",
"==",
"40",
")",
",",
"(",
"'Incorrect length of sha1 string: %d'",
"%",
"hexsha",
")",
"return",
"hexsha"
] | takes a string and returns the hex of the sha within . | train | false |
4,308 | def assert_attribute_matches(output, path, attribute, expression):
xml = xml_find(output, path)
attribute_value = xml.attrib[attribute]
if (re.match(expression, attribute_value) is None):
errmsg = ("Expected attribute '%s' on element with path '%s' to match '%s', instead attribute value was '%s'." % (attribute, path, expression, attribute_value))
raise AssertionError(errmsg)
| [
"def",
"assert_attribute_matches",
"(",
"output",
",",
"path",
",",
"attribute",
",",
"expression",
")",
":",
"xml",
"=",
"xml_find",
"(",
"output",
",",
"path",
")",
"attribute_value",
"=",
"xml",
".",
"attrib",
"[",
"attribute",
"]",
"if",
"(",
"re",
"... | asserts the specified attribute of the first element matching the specified path matches the specified regular expression . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.