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 |
|---|---|---|---|---|---|
37,597 | @task
@write
def addon_grouped_rating(*addons, **kw):
log.info(('[%s@%s] Updating addon grouped ratings.' % (len(addons), addon_grouped_rating.rate_limit)))
for addon in addons:
GroupedRating.set(addon, using='default')
| [
"@",
"task",
"@",
"write",
"def",
"addon_grouped_rating",
"(",
"*",
"addons",
",",
"**",
"kw",
")",
":",
"log",
".",
"info",
"(",
"(",
"'[%s@%s] Updating addon grouped ratings.'",
"%",
"(",
"len",
"(",
"addons",
")",
",",
"addon_grouped_rating",
".",
"rate_l... | roll up add-on ratings for the bar chart . | train | false |
37,598 | @interruptable
def _fork_posix(args, cwd=None):
encoded_args = [encode(arg) for arg in args]
return subprocess.Popen(encoded_args, cwd=cwd).pid
| [
"@",
"interruptable",
"def",
"_fork_posix",
"(",
"args",
",",
"cwd",
"=",
"None",
")",
":",
"encoded_args",
"=",
"[",
"encode",
"(",
"arg",
")",
"for",
"arg",
"in",
"args",
"]",
"return",
"subprocess",
".",
"Popen",
"(",
"encoded_args",
",",
"cwd",
"="... | launch a process in the background . | train | false |
37,599 | def encode_signing_format(data):
return '.'.join(map(str, data))
| [
"def",
"encode_signing_format",
"(",
"data",
")",
":",
"return",
"'.'",
".",
"join",
"(",
"map",
"(",
"str",
",",
"data",
")",
")"
] | prepare a iterable for singing . | train | false |
37,600 | def compute_hashes_from_fileobj(fileobj, chunk_size=(1024 * 1024)):
if (six.PY3 and hasattr(fileobj, 'mode') and ('b' not in fileobj.mode)):
raise ValueError('File-like object must be opened in binary mode!')
linear_hash = hashlib.sha256()
chunks = []
chunk = fileobj.read(chunk_size)
while chunk:
if (not isinstance(chunk, bytes)):
chunk = chunk.encode((getattr(fileobj, 'encoding', '') or 'utf-8'))
linear_hash.update(chunk)
chunks.append(hashlib.sha256(chunk).digest())
chunk = fileobj.read(chunk_size)
if (not chunks):
chunks = [hashlib.sha256('').digest()]
return (linear_hash.hexdigest(), bytes_to_hex(tree_hash(chunks)))
| [
"def",
"compute_hashes_from_fileobj",
"(",
"fileobj",
",",
"chunk_size",
"=",
"(",
"1024",
"*",
"1024",
")",
")",
":",
"if",
"(",
"six",
".",
"PY3",
"and",
"hasattr",
"(",
"fileobj",
",",
"'mode'",
")",
"and",
"(",
"'b'",
"not",
"in",
"fileobj",
".",
... | compute the linear and tree hash from a fileobj . | train | false |
37,602 | def vi_pos_matching(line, index=0):
anchor = None
target = None
delta = 1
count = 0
try:
while 1:
if (anchor is None):
try:
(target, delta) = _vi_dct_matching[line[index]]
anchor = line[index]
count = 1
except KeyError:
index += 1
continue
else:
if (index < 0):
return (-1)
if (line[index] == anchor):
count += 1
elif (line[index] == target):
count -= 1
if (count == 0):
return index
index += delta
except IndexError:
return (-1)
| [
"def",
"vi_pos_matching",
"(",
"line",
",",
"index",
"=",
"0",
")",
":",
"anchor",
"=",
"None",
"target",
"=",
"None",
"delta",
"=",
"1",
"count",
"=",
"0",
"try",
":",
"while",
"1",
":",
"if",
"(",
"anchor",
"is",
"None",
")",
":",
"try",
":",
... | find matching <> . | train | true |
37,604 | def generate_hashes(peaks, fan_value=DEFAULT_FAN_VALUE):
if PEAK_SORT:
peaks.sort(key=itemgetter(1))
for i in range(len(peaks)):
for j in range(1, fan_value):
if ((i + j) < len(peaks)):
freq1 = peaks[i][IDX_FREQ_I]
freq2 = peaks[(i + j)][IDX_FREQ_I]
t1 = peaks[i][IDX_TIME_J]
t2 = peaks[(i + j)][IDX_TIME_J]
t_delta = (t2 - t1)
if ((t_delta >= MIN_HASH_TIME_DELTA) and (t_delta <= MAX_HASH_TIME_DELTA)):
h = hashlib.sha1(('%s|%s|%s' % (str(freq1), str(freq2), str(t_delta))))
(yield (h.hexdigest()[0:FINGERPRINT_REDUCTION], t1))
| [
"def",
"generate_hashes",
"(",
"peaks",
",",
"fan_value",
"=",
"DEFAULT_FAN_VALUE",
")",
":",
"if",
"PEAK_SORT",
":",
"peaks",
".",
"sort",
"(",
"key",
"=",
"itemgetter",
"(",
"1",
")",
")",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"peaks",
")",
"... | hash list structure: sha1_hash[0:20] time_offset [ . | train | false |
37,605 | def cspline1d(signal, lamb=0.0):
if (lamb != 0.0):
return _cubic_smooth_coeff(signal, lamb)
else:
return _cubic_coeff(signal)
| [
"def",
"cspline1d",
"(",
"signal",
",",
"lamb",
"=",
"0.0",
")",
":",
"if",
"(",
"lamb",
"!=",
"0.0",
")",
":",
"return",
"_cubic_smooth_coeff",
"(",
"signal",
",",
"lamb",
")",
"else",
":",
"return",
"_cubic_coeff",
"(",
"signal",
")"
] | compute cubic spline coefficients for rank-1 array . | train | false |
37,606 | def _get_skip_method(obj):
if inspect.isclass(obj):
if (not _is_test_cls(obj)):
raise ValueError(NOT_TEST_OBJECT_ERROR_MSG)
return _mark_class_skipped
else:
if (not _is_test_method_name(obj.__name__)):
raise ValueError(NOT_TEST_OBJECT_ERROR_MSG)
return _mark_method_skipped
| [
"def",
"_get_skip_method",
"(",
"obj",
")",
":",
"if",
"inspect",
".",
"isclass",
"(",
"obj",
")",
":",
"if",
"(",
"not",
"_is_test_cls",
"(",
"obj",
")",
")",
":",
"raise",
"ValueError",
"(",
"NOT_TEST_OBJECT_ERROR_MSG",
")",
"return",
"_mark_class_skipped"... | make sure that we can decorate both methods and classes . | train | false |
37,607 | def akismet_data_as_dl(akismet_data):
favorites = ('comment_content', 'permalink', 'comment_author', 'comment_author_email')
def moderator_sort(key):
'Sort data by 1) favorites, 2) data values, 3) headers'
try:
fav_order = favorites.index(key)
except ValueError:
fav_order = len(favorites)
is_data = (key and (key[0] in ascii_lowercase))
return (fav_order, (not is_data), key)
if (not akismet_data):
return SUBMISSION_NOT_AVAILABLE
data = json.loads(akismet_data)
keys = sorted(data.keys(), key=moderator_sort)
out = format_html(u'<dl>\n {}\n</dl>', format_html_join(u'\n ', u'<dt>{}</dt><dd>{}</dd>', ((key, data[key]) for key in keys)))
return out
| [
"def",
"akismet_data_as_dl",
"(",
"akismet_data",
")",
":",
"favorites",
"=",
"(",
"'comment_content'",
",",
"'permalink'",
",",
"'comment_author'",
",",
"'comment_author_email'",
")",
"def",
"moderator_sort",
"(",
"key",
")",
":",
"try",
":",
"fav_order",
"=",
... | format akismet data as a definition list . | train | false |
37,608 | def deserialize_request_string(string, app):
server = ServerBase(app)
initial_ctx = MethodContext(server, MethodContext.SERVER)
initial_ctx.in_string = [string]
ctx = server.generate_contexts(initial_ctx)[0]
server.get_in_object(ctx)
return ctx.in_object
| [
"def",
"deserialize_request_string",
"(",
"string",
",",
"app",
")",
":",
"server",
"=",
"ServerBase",
"(",
"app",
")",
"initial_ctx",
"=",
"MethodContext",
"(",
"server",
",",
"MethodContext",
".",
"SERVER",
")",
"initial_ctx",
".",
"in_string",
"=",
"[",
"... | deserialize request string using in_protocol in application definition . | train | false |
37,610 | def subplot2grid(shape, loc, rowspan=1, colspan=1, fig=None, **kwargs):
if (fig is None):
fig = gcf()
(s1, s2) = shape
subplotspec = GridSpec(s1, s2).new_subplotspec(loc, rowspan=rowspan, colspan=colspan)
a = fig.add_subplot(subplotspec, **kwargs)
bbox = a.bbox
byebye = []
for other in fig.axes:
if (other == a):
continue
if bbox.fully_overlaps(other.bbox):
byebye.append(other)
for ax in byebye:
delaxes(ax)
return a
| [
"def",
"subplot2grid",
"(",
"shape",
",",
"loc",
",",
"rowspan",
"=",
"1",
",",
"colspan",
"=",
"1",
",",
"fig",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"if",
"(",
"fig",
"is",
"None",
")",
":",
"fig",
"=",
"gcf",
"(",
")",
"(",
"s1",
","... | create a subplot in a grid . | train | false |
37,611 | def _equal_chance_permutation(objs, field='albumartist'):
key = attrgetter(field)
objs.sort(key=key)
objs_by_artists = {}
for (artist, v) in groupby(objs, key):
objs_by_artists[artist] = list(v)
while objs_by_artists:
artist = random.choice(list(objs_by_artists.keys()))
objs_from_artist = objs_by_artists[artist]
i = random.randint(0, (len(objs_from_artist) - 1))
(yield objs_from_artist.pop(i))
if (not objs_from_artist):
del objs_by_artists[artist]
| [
"def",
"_equal_chance_permutation",
"(",
"objs",
",",
"field",
"=",
"'albumartist'",
")",
":",
"key",
"=",
"attrgetter",
"(",
"field",
")",
"objs",
".",
"sort",
"(",
"key",
"=",
"key",
")",
"objs_by_artists",
"=",
"{",
"}",
"for",
"(",
"artist",
",",
"... | generate a permutation of the objects where every group with equal values for field have an equal chance of appearing in any given position . | train | false |
37,613 | def license_absent(name):
ret = {'name': name, 'changes': {}, 'result': False, 'comment': ''}
if (not __salt__['powerpath.has_powerpath']()):
ret['result'] = False
ret['comment'] = 'PowerPath is not installed.'
return ret
licenses = [l['key'] for l in __salt__['powerpath.list_licenses']()]
if (name not in licenses):
ret['result'] = True
ret['comment'] = 'License key {0} not present'.format(name)
return ret
if __opts__['test']:
ret['result'] = None
ret['comment'] = 'License key {0} is set to be removed'.format(name)
return ret
data = __salt__['powerpath.remove_license'](name)
if data['result']:
ret['changes'] = {name: 'removed'}
ret['result'] = True
ret['comment'] = data['output']
return ret
else:
ret['result'] = False
ret['comment'] = data['output']
return ret
| [
"def",
"license_absent",
"(",
"name",
")",
":",
"ret",
"=",
"{",
"'name'",
":",
"name",
",",
"'changes'",
":",
"{",
"}",
",",
"'result'",
":",
"False",
",",
"'comment'",
":",
"''",
"}",
"if",
"(",
"not",
"__salt__",
"[",
"'powerpath.has_powerpath'",
"]... | ensures that the specified powerpath license key is absent on the host . | train | true |
37,614 | def transaction_retry(max_retries=1):
def _outer(fun):
@wraps(fun)
def _inner(*args, **kwargs):
_max_retries = kwargs.pop(u'exception_retry_count', max_retries)
for retries in count(0):
try:
return fun(*args, **kwargs)
except Exception:
if (retries >= _max_retries):
raise
try:
rollback_unless_managed()
except Exception:
pass
return _inner
return _outer
| [
"def",
"transaction_retry",
"(",
"max_retries",
"=",
"1",
")",
":",
"def",
"_outer",
"(",
"fun",
")",
":",
"@",
"wraps",
"(",
"fun",
")",
"def",
"_inner",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"_max_retries",
"=",
"kwargs",
".",
"pop",
"... | decorator for methods doing database operations . | train | true |
37,615 | def EvalNormalCdfInverse(p, mu=0, sigma=1):
return stats.norm.ppf(p, loc=mu, scale=sigma)
| [
"def",
"EvalNormalCdfInverse",
"(",
"p",
",",
"mu",
"=",
"0",
",",
"sigma",
"=",
"1",
")",
":",
"return",
"stats",
".",
"norm",
".",
"ppf",
"(",
"p",
",",
"loc",
"=",
"mu",
",",
"scale",
"=",
"sigma",
")"
] | evaluates the inverse cdf of the normal distribution . | train | false |
37,616 | def _get_Q(pi, k, w, codon_lst, codon_table):
import numpy as np
codon_num = len(codon_lst)
Q = np.zeros((codon_num, codon_num))
for i in range(codon_num):
for j in range(codon_num):
if (i != j):
Q[(i, j)] = _q(codon_lst[i], codon_lst[j], pi, k, w, codon_table=codon_table)
nucl_substitutions = 0
for i in range(codon_num):
Q[(i, i)] = (- sum(Q[i, :]))
try:
nucl_substitutions += (pi[codon_lst[i]] * (- Q[(i, i)]))
except KeyError:
pass
Q = (Q / nucl_substitutions)
return Q
| [
"def",
"_get_Q",
"(",
"pi",
",",
"k",
",",
"w",
",",
"codon_lst",
",",
"codon_table",
")",
":",
"import",
"numpy",
"as",
"np",
"codon_num",
"=",
"len",
"(",
"codon_lst",
")",
"Q",
"=",
"np",
".",
"zeros",
"(",
"(",
"codon_num",
",",
"codon_num",
")... | q matrix for codon substitution . | train | false |
37,618 | def find_errors(project, resource):
pymodule = project.get_pymodule(resource)
finder = _BadAccessFinder(pymodule)
ast.walk(pymodule.get_ast(), finder)
return finder.errors
| [
"def",
"find_errors",
"(",
"project",
",",
"resource",
")",
":",
"pymodule",
"=",
"project",
".",
"get_pymodule",
"(",
"resource",
")",
"finder",
"=",
"_BadAccessFinder",
"(",
"pymodule",
")",
"ast",
".",
"walk",
"(",
"pymodule",
".",
"get_ast",
"(",
")",
... | find possible bad name and attribute accesses it returns a list of errors . | train | true |
37,620 | def get_importer(path_item):
try:
importer = sys.path_importer_cache[path_item]
except KeyError:
for hook in sys.path_hooks:
try:
importer = hook(path_item)
except ImportError:
pass
else:
break
else:
importer = None
sys.path_importer_cache.setdefault(path_item, importer)
if (importer is None):
try:
importer = ImpWrapper(path_item)
except ImportError:
pass
return importer
| [
"def",
"get_importer",
"(",
"path_item",
")",
":",
"try",
":",
"importer",
"=",
"sys",
".",
"path_importer_cache",
"[",
"path_item",
"]",
"except",
"KeyError",
":",
"for",
"hook",
"in",
"sys",
".",
"path_hooks",
":",
"try",
":",
"importer",
"=",
"hook",
... | retrieve a pep 302 "importer" for the given path item if there is no importer . | train | true |
37,621 | def latex_to_png(s, encode=False, backend=None, wrap=False):
s = cast_unicode(s)
allowed_backends = LaTeXTool.instance().backends
if (backend is None):
backend = allowed_backends[0]
if (backend not in allowed_backends):
return None
if (backend == 'matplotlib'):
f = latex_to_png_mpl
elif (backend == 'dvipng'):
f = latex_to_png_dvipng
else:
raise ValueError('No such backend {0}'.format(backend))
bin_data = f(s, wrap)
if (encode and bin_data):
bin_data = encodebytes(bin_data)
return bin_data
| [
"def",
"latex_to_png",
"(",
"s",
",",
"encode",
"=",
"False",
",",
"backend",
"=",
"None",
",",
"wrap",
"=",
"False",
")",
":",
"s",
"=",
"cast_unicode",
"(",
"s",
")",
"allowed_backends",
"=",
"LaTeXTool",
".",
"instance",
"(",
")",
".",
"backends",
... | render a latex string to png . | train | false |
37,622 | def show_sls(mods, saltenv='base', test=None, **kwargs):
__pillar__.update(kwargs.get('pillar', {}))
__opts__['grains'] = __grains__
opts = copy.copy(__opts__)
if salt.utils.test_mode(test=test, **kwargs):
opts['test'] = True
else:
opts['test'] = __opts__.get('test', None)
st_ = salt.client.ssh.state.SSHHighState(__opts__, __pillar__, __salt__, __context__['fileclient'])
if isinstance(mods, string_types):
mods = mods.split(',')
(high_data, errors) = st_.render_highstate({saltenv: mods})
(high_data, ext_errors) = st_.state.reconcile_extend(high_data)
errors += ext_errors
errors += st_.state.verify_high(high_data)
if errors:
return errors
(high_data, req_in_errors) = st_.state.requisite_in(high_data)
errors += req_in_errors
high_data = st_.state.apply_exclude(high_data)
if errors:
return errors
return high_data
| [
"def",
"show_sls",
"(",
"mods",
",",
"saltenv",
"=",
"'base'",
",",
"test",
"=",
"None",
",",
"**",
"kwargs",
")",
":",
"__pillar__",
".",
"update",
"(",
"kwargs",
".",
"get",
"(",
"'pillar'",
",",
"{",
"}",
")",
")",
"__opts__",
"[",
"'grains'",
"... | display the state data from a specific sls or list of sls files on the master cli example: . | train | false |
37,625 | def validate_string_or_None(s):
if (s is None):
return None
try:
return six.text_type(s)
except ValueError:
raise ValueError((u'Could not convert "%s" to string' % s))
| [
"def",
"validate_string_or_None",
"(",
"s",
")",
":",
"if",
"(",
"s",
"is",
"None",
")",
":",
"return",
"None",
"try",
":",
"return",
"six",
".",
"text_type",
"(",
"s",
")",
"except",
"ValueError",
":",
"raise",
"ValueError",
"(",
"(",
"u'Could not conve... | convert s to string or raise . | train | false |
37,627 | def extract_attrs(attr_string):
attributes = {}
for (name, val) in FIND_ATTRS.findall(attr_string):
attributes[name] = val
return attributes
| [
"def",
"extract_attrs",
"(",
"attr_string",
")",
":",
"attributes",
"=",
"{",
"}",
"for",
"(",
"name",
",",
"val",
")",
"in",
"FIND_ATTRS",
".",
"findall",
"(",
"attr_string",
")",
":",
"attributes",
"[",
"name",
"]",
"=",
"val",
"return",
"attributes"
] | helper method to extract tag attributes as a dict . | train | false |
37,628 | def _consume_decimal(seq):
return (int(seq[0:2], 10), seq[2:])
| [
"def",
"_consume_decimal",
"(",
"seq",
")",
":",
"return",
"(",
"int",
"(",
"seq",
"[",
"0",
":",
"2",
"]",
",",
"10",
")",
",",
"seq",
"[",
"2",
":",
"]",
")"
] | read 2 chars as a decimal . | train | false |
37,631 | def filter_limit_query(model, query, hints):
if (hints is None):
return query
query = _filter(model, query, hints)
if hints.cannot_match:
return []
if (not hints.filters):
return _limit(query, hints)
else:
return query
| [
"def",
"filter_limit_query",
"(",
"model",
",",
"query",
",",
"hints",
")",
":",
"if",
"(",
"hints",
"is",
"None",
")",
":",
"return",
"query",
"query",
"=",
"_filter",
"(",
"model",
",",
"query",
",",
"hints",
")",
"if",
"hints",
".",
"cannot_match",
... | apply filtering and limit to a query . | train | false |
37,632 | def build_text_response(request, data, code):
return build_response(request, data, code, u'ascii')
| [
"def",
"build_text_response",
"(",
"request",
",",
"data",
",",
"code",
")",
":",
"return",
"build_response",
"(",
"request",
",",
"data",
",",
"code",
",",
"u'ascii'",
")"
] | build a response for textual data . | train | false |
37,633 | def call_ping(*args, **kwargs):
errors = dict()
for (dev_id, dev_status) in call_blink().items():
if (not dev_status['result']):
errors[dev_id] = False
return (errors or True)
| [
"def",
"call_ping",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"errors",
"=",
"dict",
"(",
")",
"for",
"(",
"dev_id",
",",
"dev_status",
")",
"in",
"call_blink",
"(",
")",
".",
"items",
"(",
")",
":",
"if",
"(",
"not",
"dev_status",
"[",
"'... | ping the lamps by issuing a short inversion blink to all available devices . | train | true |
37,634 | def find_dimension(name, locale=None, provider=None, namespace=None):
templates = {}
missing = [name]
while missing:
dimension = None
name = missing.pop()
dimension = None
required_template = None
try:
dimension = _lookup_dimension(name, templates, namespace, provider)
except TemplateRequired as e:
required_template = e.template
if (required_template in templates):
raise BackendError(("Some model provider didn't make use of dimension template '%s' for '%s'" % (required_template, name)))
if required_template:
missing.append(name)
if (required_template in missing):
raise ModelError(("Dimension templates cycle in '%s'" % required_template))
missing.append(required_template)
if dimension:
templates[name] = dimension
if namespace:
lookup = namespace.translation_lookup(locale)
if lookup:
context = LocalizationContext(lookup[0])
trans = context.object_localization('dimensions', 'inner')
dimension = dimension.localized(trans)
return dimension
| [
"def",
"find_dimension",
"(",
"name",
",",
"locale",
"=",
"None",
",",
"provider",
"=",
"None",
",",
"namespace",
"=",
"None",
")",
":",
"templates",
"=",
"{",
"}",
"missing",
"=",
"[",
"name",
"]",
"while",
"missing",
":",
"dimension",
"=",
"None",
... | returns a localized dimension with name . | train | false |
37,635 | def utf8_text(text):
if (text and text.strip()):
text = text.strip()
if (not isinstance(text, unicode)):
text = text.decode(u'utf-8', u'replace')
text = normalize(text).encode(u'utf-8')
else:
text = _(u'Unknown').encode(u'utf-8')
return text
| [
"def",
"utf8_text",
"(",
"text",
")",
":",
"if",
"(",
"text",
"and",
"text",
".",
"strip",
"(",
")",
")",
":",
"text",
"=",
"text",
".",
"strip",
"(",
")",
"if",
"(",
"not",
"isinstance",
"(",
"text",
",",
"unicode",
")",
")",
":",
"text",
"=",... | convert a possibly null string to utf-8 bytes . | train | false |
37,636 | @handle_response_format
@treeio_login_required
def task_status_delete(request, status_id, response_format='html'):
status = get_object_or_404(TaskStatus, pk=status_id)
if (not request.user.profile.has_permission(status, mode='w')):
return user_denied(request, message="You don't have access to this Task Status")
if request.POST:
if ('delete' in request.POST):
if ('trash' in request.POST):
status.trash = True
status.save()
else:
status.delete()
return HttpResponseRedirect(reverse('projects_index'))
elif ('cancel' in request.POST):
return HttpResponseRedirect(reverse('projects_index_by_status', args=[status.id]))
milestones = Object.filter_by_request(request, Milestone.objects)
context = _get_default_context(request)
context.update({'status': status, 'milestones': milestones})
return render_to_response('projects/status_delete', context, context_instance=RequestContext(request), response_format=response_format)
| [
"@",
"handle_response_format",
"@",
"treeio_login_required",
"def",
"task_status_delete",
"(",
"request",
",",
"status_id",
",",
"response_format",
"=",
"'html'",
")",
":",
"status",
"=",
"get_object_or_404",
"(",
"TaskStatus",
",",
"pk",
"=",
"status_id",
")",
"i... | delete a task status . | train | false |
37,640 | def is_sync_file(filename):
if isinstance(filename, (str, unicode)):
extension = filename.rpartition(u'.')[2].lower()
return ((extension in sickbeard.SYNC_FILES.split(u',')) or filename.startswith(u'.syncthing') or any((fnmatch(filename, match) for match in sickbeard.SYNC_FILES.split(u','))))
return False
| [
"def",
"is_sync_file",
"(",
"filename",
")",
":",
"if",
"isinstance",
"(",
"filename",
",",
"(",
"str",
",",
"unicode",
")",
")",
":",
"extension",
"=",
"filename",
".",
"rpartition",
"(",
"u'.'",
")",
"[",
"2",
"]",
".",
"lower",
"(",
")",
"return",... | check if the provided filename is a sync file . | train | false |
37,642 | def test_get_call_line():
@verbose
def foo(verbose=None):
return _get_call_line(in_verbose=True)
for v in (None, True):
my_line = foo(verbose=v)
assert_equal(my_line, 'my_line = foo(verbose=v) # testing')
def bar():
return _get_call_line(in_verbose=False)
my_line = bar()
assert_equal(my_line, 'my_line = bar() # testing more')
| [
"def",
"test_get_call_line",
"(",
")",
":",
"@",
"verbose",
"def",
"foo",
"(",
"verbose",
"=",
"None",
")",
":",
"return",
"_get_call_line",
"(",
"in_verbose",
"=",
"True",
")",
"for",
"v",
"in",
"(",
"None",
",",
"True",
")",
":",
"my_line",
"=",
"f... | test getting a call line . | train | false |
37,643 | @pytest.mark.parametrize('create_file, create_dir, filterfunc, expected', [(True, False, os.path.isfile, True), (True, False, os.path.isdir, False), (False, True, os.path.isfile, False), (False, True, os.path.isdir, True), (False, False, os.path.isfile, False), (False, False, os.path.isdir, False)])
def test_get_file_list(tmpdir, create_file, create_dir, filterfunc, expected):
path = (tmpdir / 'foo')
if (create_file or create_dir):
path.ensure(dir=create_dir)
all_files = os.listdir(str(tmpdir))
result = filescheme.get_file_list(str(tmpdir), all_files, filterfunc)
item = {'name': 'foo', 'absname': str(path)}
assert ((item in result) == expected)
| [
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'create_file, create_dir, filterfunc, expected'",
",",
"[",
"(",
"True",
",",
"False",
",",
"os",
".",
"path",
".",
"isfile",
",",
"True",
")",
",",
"(",
"True",
",",
"False",
",",
"os",
".",
"path",
... | test get_file_list . | train | false |
37,644 | def aes_decrypt(data, expanded_key):
rounds = ((len(expanded_key) // BLOCK_SIZE_BYTES) - 1)
for i in range(rounds, 0, (-1)):
data = xor(data, expanded_key[(i * BLOCK_SIZE_BYTES):((i + 1) * BLOCK_SIZE_BYTES)])
if (i != rounds):
data = mix_columns_inv(data)
data = shift_rows_inv(data)
data = sub_bytes_inv(data)
data = xor(data, expanded_key[:BLOCK_SIZE_BYTES])
return data
| [
"def",
"aes_decrypt",
"(",
"data",
",",
"expanded_key",
")",
":",
"rounds",
"=",
"(",
"(",
"len",
"(",
"expanded_key",
")",
"//",
"BLOCK_SIZE_BYTES",
")",
"-",
"1",
")",
"for",
"i",
"in",
"range",
"(",
"rounds",
",",
"0",
",",
"(",
"-",
"1",
")",
... | decrypt one block with aes . | train | false |
37,645 | def tensor_mul(*a):
if (not a):
return TensMul.from_data(S.One, [], [], [])
t = a[0]
for tx in a[1:]:
t = (t * tx)
return t
| [
"def",
"tensor_mul",
"(",
"*",
"a",
")",
":",
"if",
"(",
"not",
"a",
")",
":",
"return",
"TensMul",
".",
"from_data",
"(",
"S",
".",
"One",
",",
"[",
"]",
",",
"[",
"]",
",",
"[",
"]",
")",
"t",
"=",
"a",
"[",
"0",
"]",
"for",
"tx",
"in",... | product of tensors . | train | false |
37,647 | def check_uuid4(logical_line):
msg = 'N357: Use oslo_utils.uuidutils or uuidsentinel(in case of test cases) to generate UUID instead of uuid4().'
if ('uuid4().' in logical_line):
return
if ('uuid4()' in logical_line):
(yield (0, msg))
| [
"def",
"check_uuid4",
"(",
"logical_line",
")",
":",
"msg",
"=",
"'N357: Use oslo_utils.uuidutils or uuidsentinel(in case of test cases) to generate UUID instead of uuid4().'",
"if",
"(",
"'uuid4().'",
"in",
"logical_line",
")",
":",
"return",
"if",
"(",
"'uuid4()'",
"in",
... | generating uuid use oslo_utils . | train | false |
37,652 | def onlyOnce(fn):
def wrap(*args, **kwargs):
if hasattr(fn, 'called'):
return
fn.called = 1
return fn(*args, **kwargs)
util.mergeFunctionMetadata(fn, wrap)
return wrap
| [
"def",
"onlyOnce",
"(",
"fn",
")",
":",
"def",
"wrap",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"hasattr",
"(",
"fn",
",",
"'called'",
")",
":",
"return",
"fn",
".",
"called",
"=",
"1",
"return",
"fn",
"(",
"*",
"args",
",",
"**",... | set up fn to only run once within an interpreter instance . | train | true |
37,653 | def empty_like(array):
warnings.warn('chainer.cuda.empty_like is deprecated. Use cupy.empty_like instead.', DeprecationWarning)
check_cuda_available()
if isinstance(array, cupy.ndarray):
return cupy.empty_like(array)
return cupy.empty(array.shape, dtype=array.dtype)
| [
"def",
"empty_like",
"(",
"array",
")",
":",
"warnings",
".",
"warn",
"(",
"'chainer.cuda.empty_like is deprecated. Use cupy.empty_like instead.'",
",",
"DeprecationWarning",
")",
"check_cuda_available",
"(",
")",
"if",
"isinstance",
"(",
"array",
",",
"cupy",
".",
"n... | creates an uninitialized gpu array like the given one . | train | false |
37,654 | def dtype_in_elemwise_supported(op):
def get_all_basic_scalar(composite_op):
l = []
for i in composite_op.fgraph.toposort():
if isinstance(i, theano.scalar.Composite):
l += get_all_basic_scalar(i)
else:
l.append(i)
return l
if (isinstance(op, GpuElemwise) or isinstance(op, tensor.Elemwise)):
if isinstance(op.scalar_op, theano.scalar.Composite):
scals = get_all_basic_scalar(op.scalar_op)
for s in scals:
if any([(i.type.dtype not in elemwise_cuda_dtype_supported) for i in (s.inputs + s.outputs)]):
return False
return True
| [
"def",
"dtype_in_elemwise_supported",
"(",
"op",
")",
":",
"def",
"get_all_basic_scalar",
"(",
"composite_op",
")",
":",
"l",
"=",
"[",
"]",
"for",
"i",
"in",
"composite_op",
".",
"fgraph",
".",
"toposort",
"(",
")",
":",
"if",
"isinstance",
"(",
"i",
",... | return true of the elemwise op is supported on the gpu . | train | false |
37,656 | def decompose_fullname(fullname):
from r2.lib.db.thing import Thing, Relation
if (fullname[0] == 't'):
type_class = Thing
elif (fullname[0] == 'r'):
type_class = Relation
(type_id36, thing_id36) = fullname[1:].split('_')
type_id = int(type_id36, 36)
id = int(thing_id36, 36)
return (type_class, type_id, id)
| [
"def",
"decompose_fullname",
"(",
"fullname",
")",
":",
"from",
"r2",
".",
"lib",
".",
"db",
".",
"thing",
"import",
"Thing",
",",
"Relation",
"if",
"(",
"fullname",
"[",
"0",
"]",
"==",
"'t'",
")",
":",
"type_class",
"=",
"Thing",
"elif",
"(",
"full... | decompose_fullname -> . | train | false |
37,657 | def system_load(pl, format=u'{avg:.1f}', threshold_good=1, threshold_bad=2, track_cpu_count=False, short=False):
global cpu_count
try:
cpu_num = cpu_count = (_cpu_count() if ((cpu_count is None) or track_cpu_count) else cpu_count)
except NotImplementedError:
pl.warn(u'Unable to get CPU count: method is not implemented')
return None
ret = []
for avg in os.getloadavg():
normalized = (avg / cpu_num)
if (normalized < threshold_good):
gradient_level = 0
elif (normalized < threshold_bad):
gradient_level = (((normalized - threshold_good) * 100.0) / (threshold_bad - threshold_good))
else:
gradient_level = 100
ret.append({u'contents': format.format(avg=avg), u'highlight_groups': [u'system_load_gradient', u'system_load'], u'divider_highlight_group': u'background:divider', u'gradient_level': gradient_level})
if short:
return ret
ret[0][u'contents'] += u' '
ret[1][u'contents'] += u' '
return ret
| [
"def",
"system_load",
"(",
"pl",
",",
"format",
"=",
"u'{avg:.1f}'",
",",
"threshold_good",
"=",
"1",
",",
"threshold_bad",
"=",
"2",
",",
"track_cpu_count",
"=",
"False",
",",
"short",
"=",
"False",
")",
":",
"global",
"cpu_count",
"try",
":",
"cpu_num",
... | return system load average . | train | false |
37,659 | def test_stacked_line_log():
stacked = StackedLine(logarithmic=True)
stacked.add('one_two', [1, 2])
stacked.add('ten_twelve', [10, 12])
q = stacked.render_pyquery()
assert (set([v.text for v in q('desc.value')]) == set(('1', '2', '11 (+10)', '14 (+12)')))
| [
"def",
"test_stacked_line_log",
"(",
")",
":",
"stacked",
"=",
"StackedLine",
"(",
"logarithmic",
"=",
"True",
")",
"stacked",
".",
"add",
"(",
"'one_two'",
",",
"[",
"1",
",",
"2",
"]",
")",
"stacked",
".",
"add",
"(",
"'ten_twelve'",
",",
"[",
"10",
... | test logarithmic stacked line . | train | false |
37,660 | def get_characteristic_subpattern(subpatterns):
if (not isinstance(subpatterns, list)):
return subpatterns
if (len(subpatterns) == 1):
return subpatterns[0]
subpatterns_with_names = []
subpatterns_with_common_names = []
common_names = ['in', 'for', 'if', 'not', 'None']
subpatterns_with_common_chars = []
common_chars = '[]().,:'
for subpattern in subpatterns:
if any(rec_test(subpattern, (lambda x: (type(x) is str)))):
if any(rec_test(subpattern, (lambda x: (isinstance(x, str) and (x in common_chars))))):
subpatterns_with_common_chars.append(subpattern)
elif any(rec_test(subpattern, (lambda x: (isinstance(x, str) and (x in common_names))))):
subpatterns_with_common_names.append(subpattern)
else:
subpatterns_with_names.append(subpattern)
if subpatterns_with_names:
subpatterns = subpatterns_with_names
elif subpatterns_with_common_names:
subpatterns = subpatterns_with_common_names
elif subpatterns_with_common_chars:
subpatterns = subpatterns_with_common_chars
return max(subpatterns, key=len)
| [
"def",
"get_characteristic_subpattern",
"(",
"subpatterns",
")",
":",
"if",
"(",
"not",
"isinstance",
"(",
"subpatterns",
",",
"list",
")",
")",
":",
"return",
"subpatterns",
"if",
"(",
"len",
"(",
"subpatterns",
")",
"==",
"1",
")",
":",
"return",
"subpat... | picks the most characteristic from a list of linear patterns current order used is: names > common_names > common_chars . | train | true |
37,661 | def backend(comment, content_object, request):
return (len(comment.comment.split()) < COMMENT_MIN_WORDS)
| [
"def",
"backend",
"(",
"comment",
",",
"content_object",
",",
"request",
")",
":",
"return",
"(",
"len",
"(",
"comment",
".",
"comment",
".",
"split",
"(",
")",
")",
"<",
"COMMENT_MIN_WORDS",
")"
] | backend for setting all comments to spam . | train | false |
37,665 | def isIntentSupported(profile, intent, direction):
try:
if (not isinstance(profile, ImageCmsProfile)):
profile = ImageCmsProfile(profile)
if profile.profile.is_intent_supported(intent, direction):
return 1
else:
return (-1)
except (AttributeError, IOError, TypeError, ValueError) as v:
raise PyCMSError(v)
| [
"def",
"isIntentSupported",
"(",
"profile",
",",
"intent",
",",
"direction",
")",
":",
"try",
":",
"if",
"(",
"not",
"isinstance",
"(",
"profile",
",",
"ImageCmsProfile",
")",
")",
":",
"profile",
"=",
"ImageCmsProfile",
"(",
"profile",
")",
"if",
"profile... | checks if a given intent is supported . | train | false |
37,667 | def dmp_exquo(f, g, u, K):
(q, r) = dmp_div(f, g, u, K)
if dmp_zero_p(r, u):
return q
else:
raise ExactQuotientFailed(f, g)
| [
"def",
"dmp_exquo",
"(",
"f",
",",
"g",
",",
"u",
",",
"K",
")",
":",
"(",
"q",
",",
"r",
")",
"=",
"dmp_div",
"(",
"f",
",",
"g",
",",
"u",
",",
"K",
")",
"if",
"dmp_zero_p",
"(",
"r",
",",
"u",
")",
":",
"return",
"q",
"else",
":",
"r... | returns polynomial quotient in k[x] . | train | false |
37,668 | def page_to_html_path(page):
source_path = page.sources_relative_to_buildroot()[0]
return (os.path.splitext(source_path)[0] + u'.html')
| [
"def",
"page_to_html_path",
"(",
"page",
")",
":",
"source_path",
"=",
"page",
".",
"sources_relative_to_buildroot",
"(",
")",
"[",
"0",
"]",
"return",
"(",
"os",
".",
"path",
".",
"splitext",
"(",
"source_path",
")",
"[",
"0",
"]",
"+",
"u'.html'",
")"
... | given a page target . | train | false |
37,669 | def html_output_graph(self, node):
graph = node['graph']
parts = node['parts']
graph_hash = get_graph_hash(node)
name = ('inheritance%s' % graph_hash)
path = '_images'
dest_path = os.path.join(setup.app.builder.outdir, path)
if (not os.path.exists(dest_path)):
os.makedirs(dest_path)
png_path = os.path.join(dest_path, (name + '.png'))
path = setup.app.builder.imgpath
urls = {}
for child in node:
if (child.get('refuri') is not None):
urls[child['reftitle']] = child.get('refuri')
elif (child.get('refid') is not None):
urls[child['reftitle']] = ('#' + child.get('refid'))
image_map = graph.run_dot(['-Tpng', ('-o%s' % png_path), '-Tcmapx'], name, parts, urls)
return ('<img src="%s/%s.png" usemap="#%s" class="inheritance"/>%s' % (path, name, name, image_map))
| [
"def",
"html_output_graph",
"(",
"self",
",",
"node",
")",
":",
"graph",
"=",
"node",
"[",
"'graph'",
"]",
"parts",
"=",
"node",
"[",
"'parts'",
"]",
"graph_hash",
"=",
"get_graph_hash",
"(",
"node",
")",
"name",
"=",
"(",
"'inheritance%s'",
"%",
"graph_... | output the graph for html . | train | true |
37,670 | def discoverYadis(uri):
response = yadisDiscover(uri)
yadis_url = response.normalized_uri
body = response.response_text
try:
openid_services = OpenIDServiceEndpoint.fromXRDS(yadis_url, body)
except XRDSError:
openid_services = []
if (not openid_services):
if response.isXRDS():
return discoverNoYadis(uri)
openid_services = OpenIDServiceEndpoint.fromHTML(yadis_url, body)
return (yadis_url, getOPOrUserServices(openid_services))
| [
"def",
"discoverYadis",
"(",
"uri",
")",
":",
"response",
"=",
"yadisDiscover",
"(",
"uri",
")",
"yadis_url",
"=",
"response",
".",
"normalized_uri",
"body",
"=",
"response",
".",
"response_text",
"try",
":",
"openid_services",
"=",
"OpenIDServiceEndpoint",
".",... | discover openid services for a uri . | train | true |
37,672 | def nbsp(x):
return x.replace(u' ', u'\xa0')
| [
"def",
"nbsp",
"(",
"x",
")",
":",
"return",
"x",
".",
"replace",
"(",
"u' '",
",",
"u'\\xa0'",
")"
] | convert space to non-breaking space . | train | false |
37,673 | def set_cors_headers_for_response(response):
if (config.get(u'ckan.cors.origin_allow_all') and request.headers.get(u'Origin')):
cors_origin_allowed = None
if asbool(config.get(u'ckan.cors.origin_allow_all')):
cors_origin_allowed = u'*'
elif (config.get(u'ckan.cors.origin_whitelist') and (request.headers.get(u'Origin') in config[u'ckan.cors.origin_whitelist'].split(u' '))):
cors_origin_allowed = request.headers.get(u'Origin')
if (cors_origin_allowed is not None):
response.headers[u'Access-Control-Allow-Origin'] = cors_origin_allowed
response.headers[u'Access-Control-Allow-Methods'] = u'POST, PUT, GET, DELETE, OPTIONS'
response.headers[u'Access-Control-Allow-Headers'] = u'X-CKAN-API-KEY, Authorization, Content-Type'
return response
| [
"def",
"set_cors_headers_for_response",
"(",
"response",
")",
":",
"if",
"(",
"config",
".",
"get",
"(",
"u'ckan.cors.origin_allow_all'",
")",
"and",
"request",
".",
"headers",
".",
"get",
"(",
"u'Origin'",
")",
")",
":",
"cors_origin_allowed",
"=",
"None",
"i... | set up access control allow headers if either origin_allow_all is true . | train | false |
37,676 | def test_pprint_break_repr():
output = pretty.pretty(BreakingReprParent())
expected = 'TG: Breaking(\n ):'
nt.assert_equal(output, expected)
| [
"def",
"test_pprint_break_repr",
"(",
")",
":",
"output",
"=",
"pretty",
".",
"pretty",
"(",
"BreakingReprParent",
"(",
")",
")",
"expected",
"=",
"'TG: Breaking(\\n ):'",
"nt",
".",
"assert_equal",
"(",
"output",
",",
"expected",
")"
] | test that p . | train | false |
37,677 | def nos_unknown_host_cb(host, fingerprint):
return True
| [
"def",
"nos_unknown_host_cb",
"(",
"host",
",",
"fingerprint",
")",
":",
"return",
"True"
] | an unknown host callback . | train | false |
37,678 | def int32_as_f32(builder, val):
assert (val.type == Type.int(32))
return builder.bitcast(val, Type.float())
| [
"def",
"int32_as_f32",
"(",
"builder",
",",
"val",
")",
":",
"assert",
"(",
"val",
".",
"type",
"==",
"Type",
".",
"int",
"(",
"32",
")",
")",
"return",
"builder",
".",
"bitcast",
"(",
"val",
",",
"Type",
".",
"float",
"(",
")",
")"
] | bitcast a 32-bit integer into a float . | train | false |
37,683 | def format_valid_streams(plugin, streams):
delimiter = ', '
validstreams = []
for (name, stream) in sorted(streams.items(), key=(lambda stream: plugin.stream_weight(stream[0]))):
if (name in STREAM_SYNONYMS):
continue
synonymfilter = (lambda n: ((stream is streams[n]) and (n is not name)))
synonyms = list(filter(synonymfilter, streams.keys()))
if (len(synonyms) > 0):
joined = delimiter.join(synonyms)
name = '{0} ({1})'.format(name, joined)
validstreams.append(name)
return delimiter.join(validstreams)
| [
"def",
"format_valid_streams",
"(",
"plugin",
",",
"streams",
")",
":",
"delimiter",
"=",
"', '",
"validstreams",
"=",
"[",
"]",
"for",
"(",
"name",
",",
"stream",
")",
"in",
"sorted",
"(",
"streams",
".",
"items",
"(",
")",
",",
"key",
"=",
"(",
"la... | formats a dict of streams . | train | true |
37,684 | def get_properties_of_kind(kind, start=None, end=None):
q = Property.all(keys_only=True)
q.ancestor(Property.key_for_kind(kind))
if ((start is not None) and (start != '')):
q.filter('__key__ >=', Property.key_for_property(kind, start))
if (end is not None):
if (end == ''):
return []
q.filter('__key__ <', Property.key_for_property(kind, end))
return [Property.key_to_property(x) for x in q.run()]
| [
"def",
"get_properties_of_kind",
"(",
"kind",
",",
"start",
"=",
"None",
",",
"end",
"=",
"None",
")",
":",
"q",
"=",
"Property",
".",
"all",
"(",
"keys_only",
"=",
"True",
")",
"q",
".",
"ancestor",
"(",
"Property",
".",
"key_for_kind",
"(",
"kind",
... | return all properties of kind in the specified range . | train | false |
37,685 | def eye(n, cls=None):
if (cls is None):
from sympy.matrices import Matrix as cls
return cls.eye(n)
| [
"def",
"eye",
"(",
"n",
",",
"cls",
"=",
"None",
")",
":",
"if",
"(",
"cls",
"is",
"None",
")",
":",
"from",
"sympy",
".",
"matrices",
"import",
"Matrix",
"as",
"cls",
"return",
"cls",
".",
"eye",
"(",
"n",
")"
] | return a 2-d array with ones on the diagonal and zeros elsewhere . | train | false |
37,687 | def test_sobel_mask():
np.random.seed(0)
result = filters.sobel(np.random.uniform(size=(10, 10)), np.zeros((10, 10), bool))
assert np.all((result == 0))
| [
"def",
"test_sobel_mask",
"(",
")",
":",
"np",
".",
"random",
".",
"seed",
"(",
"0",
")",
"result",
"=",
"filters",
".",
"sobel",
"(",
"np",
".",
"random",
".",
"uniform",
"(",
"size",
"=",
"(",
"10",
",",
"10",
")",
")",
",",
"np",
".",
"zeros... | sobel on a masked array should be zero . | train | false |
37,688 | def update_in(d, keys, func, default=None, factory=dict):
assert (len(keys) > 0)
(k, ks) = (keys[0], keys[1:])
if ks:
return assoc(d, k, update_in((d[k] if (k in d) else factory()), ks, func, default, factory), factory)
else:
innermost = (func(d[k]) if (k in d) else func(default))
return assoc(d, k, innermost, factory)
| [
"def",
"update_in",
"(",
"d",
",",
"keys",
",",
"func",
",",
"default",
"=",
"None",
",",
"factory",
"=",
"dict",
")",
":",
"assert",
"(",
"len",
"(",
"keys",
")",
">",
"0",
")",
"(",
"k",
",",
"ks",
")",
"=",
"(",
"keys",
"[",
"0",
"]",
",... | update value in a nested dictionary inputs: d - dictionary on which to operate keys - list or tuple giving the location of the value to be changed in d func - function to operate on that value if keys == [k0 . | train | false |
37,689 | def _mkv_screen_size(filename):
try:
if filename.endswith(u'.mkv'):
with io.open(filename, u'rb') as f:
mkv = MKV(f)
return (mkv.video_tracks[0].width, mkv.video_tracks[0].height)
except Exception:
pass
return (None, None)
| [
"def",
"_mkv_screen_size",
"(",
"filename",
")",
":",
"try",
":",
"if",
"filename",
".",
"endswith",
"(",
"u'.mkv'",
")",
":",
"with",
"io",
".",
"open",
"(",
"filename",
",",
"u'rb'",
")",
"as",
"f",
":",
"mkv",
"=",
"MKV",
"(",
"f",
")",
"return"... | parses mkv file for width and height . | train | false |
37,691 | def program_is_alive(program_name, pid_files_dir=None):
pid = get_pid_from_file(program_name, pid_files_dir)
if (pid is None):
return False
return pid_is_alive(pid)
| [
"def",
"program_is_alive",
"(",
"program_name",
",",
"pid_files_dir",
"=",
"None",
")",
":",
"pid",
"=",
"get_pid_from_file",
"(",
"program_name",
",",
"pid_files_dir",
")",
"if",
"(",
"pid",
"is",
"None",
")",
":",
"return",
"False",
"return",
"pid_is_alive",... | checks if the process is alive and not in zombie state . | train | false |
37,692 | def structure_tensor_eigvals(Axx, Axy, Ayy):
return _image_orthogonal_matrix22_eigvals(Axx, Axy, Ayy)
| [
"def",
"structure_tensor_eigvals",
"(",
"Axx",
",",
"Axy",
",",
"Ayy",
")",
":",
"return",
"_image_orthogonal_matrix22_eigvals",
"(",
"Axx",
",",
"Axy",
",",
"Ayy",
")"
] | compute eigen values of structure tensor . | train | false |
37,693 | def setup_desktop_icons(data):
from frappe.desk.doctype.desktop_icon.desktop_icon import set_desktop_icons
if data.desktop_icons:
set_desktop_icons(data.desktop_icons)
| [
"def",
"setup_desktop_icons",
"(",
"data",
")",
":",
"from",
"frappe",
".",
"desk",
".",
"doctype",
".",
"desktop_icon",
".",
"desktop_icon",
"import",
"set_desktop_icons",
"if",
"data",
".",
"desktop_icons",
":",
"set_desktop_icons",
"(",
"data",
".",
"desktop_... | set desktop icons form data . | train | false |
37,694 | def get_exp_with_draft_applied(exp_id, user_id):
exp_user_data = user_models.ExplorationUserDataModel.get(user_id, exp_id)
exploration = get_exploration_by_id(exp_id)
return (apply_change_list(exp_id, exp_user_data.draft_change_list) if (exp_user_data and exp_user_data.draft_change_list and is_version_of_draft_valid(exp_id, exp_user_data.draft_change_list_exp_version)) else exploration)
| [
"def",
"get_exp_with_draft_applied",
"(",
"exp_id",
",",
"user_id",
")",
":",
"exp_user_data",
"=",
"user_models",
".",
"ExplorationUserDataModel",
".",
"get",
"(",
"user_id",
",",
"exp_id",
")",
"exploration",
"=",
"get_exploration_by_id",
"(",
"exp_id",
")",
"re... | if a draft exists for the given user and exploration . | train | false |
37,695 | def test_testing():
assert_raises(AssertionError, assert_in, 'foo', 'bar')
assert_in('foo', 'foobar')
assert_raises(AssertionError, assert_not_in, 'foo', 'foobar')
assert_not_in('foo', 'bar')
assert_raises(AssertionError, assert_is, None, 0)
assert_is(None, None)
| [
"def",
"test_testing",
"(",
")",
":",
"assert_raises",
"(",
"AssertionError",
",",
"assert_in",
",",
"'foo'",
",",
"'bar'",
")",
"assert_in",
"(",
"'foo'",
",",
"'foobar'",
")",
"assert_raises",
"(",
"AssertionError",
",",
"assert_not_in",
",",
"'foo'",
",",
... | test testing ports . | train | false |
37,698 | def _FSpecialGauss(size, sigma):
radius = (size // 2)
offset = 0.0
(start, stop) = ((- radius), (radius + 1))
if ((size % 2) == 0):
offset = 0.5
stop -= 1
(x, y) = np.mgrid[(offset + start):stop, (offset + start):stop]
assert (len(x) == size)
g = np.exp((- (((x ** 2) + (y ** 2)) / (2.0 * (sigma ** 2)))))
return (g / g.sum())
| [
"def",
"_FSpecialGauss",
"(",
"size",
",",
"sigma",
")",
":",
"radius",
"=",
"(",
"size",
"//",
"2",
")",
"offset",
"=",
"0.0",
"(",
"start",
",",
"stop",
")",
"=",
"(",
"(",
"-",
"radius",
")",
",",
"(",
"radius",
"+",
"1",
")",
")",
"if",
"... | function to mimic the fspecial gaussian matlab function . | train | false |
37,699 | def BuildFileTargets(target_list, build_file):
return [p for p in target_list if (BuildFile(p) == build_file)]
| [
"def",
"BuildFileTargets",
"(",
"target_list",
",",
"build_file",
")",
":",
"return",
"[",
"p",
"for",
"p",
"in",
"target_list",
"if",
"(",
"BuildFile",
"(",
"p",
")",
"==",
"build_file",
")",
"]"
] | from a target_list . | train | false |
37,700 | def _appendArgs(url, args):
if hasattr(args, 'items'):
args = args.items()
args.sort()
if (len(args) == 0):
return url
if ('?' in url.rstrip('?')):
sep = '&'
else:
sep = '?'
return ('%s%s%s' % (url, sep, urlencode(args)))
| [
"def",
"_appendArgs",
"(",
"url",
",",
"args",
")",
":",
"if",
"hasattr",
"(",
"args",
",",
"'items'",
")",
":",
"args",
"=",
"args",
".",
"items",
"(",
")",
"args",
".",
"sort",
"(",
")",
"if",
"(",
"len",
"(",
"args",
")",
"==",
"0",
")",
"... | append some arguments to an http query . | train | true |
37,701 | def make_config():
global _BASE_CONFIG
_BASE_CONFIG = tools.make_example_config(AIO_CONFIG_FILE, CONFD)
tools.write_example_config(USER_CONFIG_FILE, _BASE_CONFIG)
| [
"def",
"make_config",
"(",
")",
":",
"global",
"_BASE_CONFIG",
"_BASE_CONFIG",
"=",
"tools",
".",
"make_example_config",
"(",
"AIO_CONFIG_FILE",
",",
"CONFD",
")",
"tools",
".",
"write_example_config",
"(",
"USER_CONFIG_FILE",
",",
"_BASE_CONFIG",
")"
] | build an inventory configuration from the sample aio files . | train | false |
37,703 | def _TruncDelta(timedelta):
return datetime.timedelta(days=timedelta.days, seconds=timedelta.seconds)
| [
"def",
"_TruncDelta",
"(",
"timedelta",
")",
":",
"return",
"datetime",
".",
"timedelta",
"(",
"days",
"=",
"timedelta",
".",
"days",
",",
"seconds",
"=",
"timedelta",
".",
"seconds",
")"
] | strips the microseconds field from a timedelta . | train | false |
37,704 | def render_field_and_label(field, label, field_class=u'', label_for=None, label_class=u'', layout=u'', **kwargs):
if (layout == u'horizontal'):
if (not label_class):
label_class = get_bootstrap_setting(u'horizontal_label_class')
if (not field_class):
field_class = get_bootstrap_setting(u'horizontal_field_class')
if (not label):
label = mark_safe(u' ')
label_class = add_css_class(label_class, u'control-label')
html = field
if field_class:
html = u'<div class="{klass}">{html}</div>'.format(klass=field_class, html=html)
if label:
html = (render_label(label, label_for=label_for, label_class=label_class) + html)
return html
| [
"def",
"render_field_and_label",
"(",
"field",
",",
"label",
",",
"field_class",
"=",
"u''",
",",
"label_for",
"=",
"None",
",",
"label_class",
"=",
"u''",
",",
"layout",
"=",
"u''",
",",
"**",
"kwargs",
")",
":",
"if",
"(",
"layout",
"==",
"u'horizontal... | render a field with its label . | train | false |
37,706 | def create_identity_pool(IdentityPoolName, AllowUnauthenticatedIdentities=False, SupportedLoginProviders=None, DeveloperProviderName=None, OpenIdConnectProviderARNs=None, region=None, key=None, keyid=None, profile=None):
SupportedLoginProviders = (dict() if (SupportedLoginProviders is None) else SupportedLoginProviders)
OpenIdConnectProviderARNs = (list() if (OpenIdConnectProviderARNs is None) else OpenIdConnectProviderARNs)
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
try:
request_params = dict(IdentityPoolName=IdentityPoolName, AllowUnauthenticatedIdentities=AllowUnauthenticatedIdentities, SupportedLoginProviders=SupportedLoginProviders, OpenIdConnectProviderARNs=OpenIdConnectProviderARNs)
if DeveloperProviderName:
request_params['DeveloperProviderName'] = DeveloperProviderName
response = conn.create_identity_pool(**request_params)
response.pop('ResponseMetadata', None)
return {'created': True, 'identity_pool': response}
except ClientError as e:
return {'created': False, 'error': salt.utils.boto3.get_error(e)}
| [
"def",
"create_identity_pool",
"(",
"IdentityPoolName",
",",
"AllowUnauthenticatedIdentities",
"=",
"False",
",",
"SupportedLoginProviders",
"=",
"None",
",",
"DeveloperProviderName",
"=",
"None",
",",
"OpenIdConnectProviderARNs",
"=",
"None",
",",
"region",
"=",
"None"... | creates a new identity pool . | train | true |
37,707 | def download_private_file(path):
try:
check_file_permission(path)
except frappe.PermissionError:
raise Forbidden(_(u"You don't have permission to access this file"))
return send_private_file(path.split(u'/private', 1)[1])
| [
"def",
"download_private_file",
"(",
"path",
")",
":",
"try",
":",
"check_file_permission",
"(",
"path",
")",
"except",
"frappe",
".",
"PermissionError",
":",
"raise",
"Forbidden",
"(",
"_",
"(",
"u\"You don't have permission to access this file\"",
")",
")",
"retur... | checks permissions and sends back private file . | train | false |
37,708 | def all_discrete(comp_dists):
if isinstance(comp_dists, Distribution):
return isinstance(comp_dists, Discrete)
else:
return all((isinstance(comp_dist, Discrete) for comp_dist in comp_dists))
| [
"def",
"all_discrete",
"(",
"comp_dists",
")",
":",
"if",
"isinstance",
"(",
"comp_dists",
",",
"Distribution",
")",
":",
"return",
"isinstance",
"(",
"comp_dists",
",",
"Discrete",
")",
"else",
":",
"return",
"all",
"(",
"(",
"isinstance",
"(",
"comp_dist",... | determine if all distributions in comp_dists are discrete . | train | false |
37,709 | def _eq_10_42(lam_1, lam_2, t_12):
a = (0.5 * (lam_1 + lam_2))
b = (0.5 * (lam_1 - lam_2))
return ((t_12 * np.exp(a)) * _sinch(b))
| [
"def",
"_eq_10_42",
"(",
"lam_1",
",",
"lam_2",
",",
"t_12",
")",
":",
"a",
"=",
"(",
"0.5",
"*",
"(",
"lam_1",
"+",
"lam_2",
")",
")",
"b",
"=",
"(",
"0.5",
"*",
"(",
"lam_1",
"-",
"lam_2",
")",
")",
"return",
"(",
"(",
"t_12",
"*",
"np",
... | equation of functions of matrices: theory and computation . | train | false |
37,710 | @must_have_permission(ADMIN)
@must_be_branched_from_node
def submit_draft_for_review(auth, node, draft, *args, **kwargs):
data = request.get_json()
meta = {}
registration_choice = data.get('registrationChoice', 'immediate')
validate_registration_choice(registration_choice)
if (registration_choice == 'embargo'):
end_date_string = data['embargoEndDate']
validate_embargo_end_date(end_date_string, node)
meta['embargo_end_date'] = end_date_string
meta['registration_choice'] = registration_choice
draft.submit_for_review(initiated_by=auth.user, meta=meta, save=True)
if (prereg_utils.get_prereg_schema() == draft.registration_schema):
node.add_log(action=NodeLog.PREREG_REGISTRATION_INITIATED, params={'node': node._primary_key}, auth=auth, save=False)
node.save()
push_status_message(language.AFTER_SUBMIT_FOR_REVIEW, kind='info', trust=False)
return ({'status': 'initiated', 'urls': {'registrations': node.web_url_for('node_registrations')}}, http.ACCEPTED)
| [
"@",
"must_have_permission",
"(",
"ADMIN",
")",
"@",
"must_be_branched_from_node",
"def",
"submit_draft_for_review",
"(",
"auth",
",",
"node",
",",
"draft",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"data",
"=",
"request",
".",
"get_json",
"(",
")",
... | submit for approvals and/or notifications :return: serialized registration :rtype: dict :raises: httperror if embargo end date is invalid . | train | false |
37,712 | def xonfig_main(args=None):
if ((not args) or ((args[0] not in _XONFIG_MAIN_ACTIONS) and (args[0] not in {'-h', '--help'}))):
args.insert(0, 'info')
parser = _xonfig_create_parser()
ns = parser.parse_args(args)
if (ns.action is None):
ns = parser.parse_args((['info'] + args))
return _XONFIG_MAIN_ACTIONS[ns.action](ns)
| [
"def",
"xonfig_main",
"(",
"args",
"=",
"None",
")",
":",
"if",
"(",
"(",
"not",
"args",
")",
"or",
"(",
"(",
"args",
"[",
"0",
"]",
"not",
"in",
"_XONFIG_MAIN_ACTIONS",
")",
"and",
"(",
"args",
"[",
"0",
"]",
"not",
"in",
"{",
"'-h'",
",",
"'-... | main xonfig entry point . | train | false |
37,714 | @loader_option()
def joinedload(loadopt, attr, innerjoin=None):
loader = loadopt.set_relationship_strategy(attr, {'lazy': 'joined'})
if (innerjoin is not None):
loader.local_opts['innerjoin'] = innerjoin
return loader
| [
"@",
"loader_option",
"(",
")",
"def",
"joinedload",
"(",
"loadopt",
",",
"attr",
",",
"innerjoin",
"=",
"None",
")",
":",
"loader",
"=",
"loadopt",
".",
"set_relationship_strategy",
"(",
"attr",
",",
"{",
"'lazy'",
":",
"'joined'",
"}",
")",
"if",
"(",
... | indicate that the given attribute should be loaded using joined eager loading . | train | false |
37,715 | def is_weighted(G, edge=None, weight='weight'):
if (edge is not None):
data = G.get_edge_data(*edge)
if (data is None):
msg = 'Edge {!r} does not exist.'.format(edge)
raise nx.NetworkXError(msg)
return (weight in data)
if is_empty(G):
return False
return all(((weight in data) for (u, v, data) in G.edges(data=True)))
| [
"def",
"is_weighted",
"(",
"G",
",",
"edge",
"=",
"None",
",",
"weight",
"=",
"'weight'",
")",
":",
"if",
"(",
"edge",
"is",
"not",
"None",
")",
":",
"data",
"=",
"G",
".",
"get_edge_data",
"(",
"*",
"edge",
")",
"if",
"(",
"data",
"is",
"None",
... | returns true if g has weighted edges . | train | false |
37,716 | def _get_filter_query(args):
query = Q()
for arg in args:
if (hasattr(Document, arg) and args[arg]):
append = Q(**{str((('document__' + arg) + '__id')): long(args[arg])})
append = (append | Q(**{str((('file__' + arg) + '__id')): long(args[arg])}))
append = (append | Q(**{str((('weblink__' + arg) + '__id')): long(args[arg])}))
query = (query & append)
return query
| [
"def",
"_get_filter_query",
"(",
"args",
")",
":",
"query",
"=",
"Q",
"(",
")",
"for",
"arg",
"in",
"args",
":",
"if",
"(",
"hasattr",
"(",
"Document",
",",
"arg",
")",
"and",
"args",
"[",
"arg",
"]",
")",
":",
"append",
"=",
"Q",
"(",
"**",
"{... | creates a query to filter identities based on filterform arguments . | train | false |
37,717 | def _gen_index_name(keys):
return _UUNDER.join([('%s_%s' % item) for item in keys])
| [
"def",
"_gen_index_name",
"(",
"keys",
")",
":",
"return",
"_UUNDER",
".",
"join",
"(",
"[",
"(",
"'%s_%s'",
"%",
"item",
")",
"for",
"item",
"in",
"keys",
"]",
")"
] | generate an index name from the set of fields it is over . | train | false |
37,718 | def dirbrowser_html(path):
title = 'Browse directory: {}'.format(path)
if is_root(path):
parent = None
else:
parent = parent_dir(path)
try:
all_files = os.listdir(path)
except OSError as e:
html = jinja.render('error.html', title='Error while reading directory', url='file:///{}'.format(path), error=str(e), icon='')
return html.encode('UTF-8', errors='xmlcharrefreplace')
files = get_file_list(path, all_files, os.path.isfile)
directories = get_file_list(path, all_files, os.path.isdir)
html = jinja.render('dirbrowser.html', title=title, url=path, icon='', parent=parent, files=files, directories=directories)
return html.encode('UTF-8', errors='xmlcharrefreplace')
| [
"def",
"dirbrowser_html",
"(",
"path",
")",
":",
"title",
"=",
"'Browse directory: {}'",
".",
"format",
"(",
"path",
")",
"if",
"is_root",
"(",
"path",
")",
":",
"parent",
"=",
"None",
"else",
":",
"parent",
"=",
"parent_dir",
"(",
"path",
")",
"try",
... | get the directory browser web page . | train | false |
37,720 | def dmp_fateman_poly_F_2(n, K):
u = [K(1), K(0)]
for i in range(0, (n - 1)):
u = [dmp_one(i, K), u]
m = (n - 1)
v = dmp_add_term(u, dmp_ground(K(2), (m - 1)), 0, n, K)
f = dmp_sqr([dmp_one(m, K), dmp_neg(v, m, K)], n, K)
g = dmp_sqr([dmp_one(m, K), v], n, K)
v = dmp_add_term(u, dmp_one((m - 1), K), 0, n, K)
h = dmp_sqr([dmp_one(m, K), v], n, K)
return (dmp_mul(f, h, n, K), dmp_mul(g, h, n, K), h)
| [
"def",
"dmp_fateman_poly_F_2",
"(",
"n",
",",
"K",
")",
":",
"u",
"=",
"[",
"K",
"(",
"1",
")",
",",
"K",
"(",
"0",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"0",
",",
"(",
"n",
"-",
"1",
")",
")",
":",
"u",
"=",
"[",
"dmp_one",
"(",
"i... | fatemans gcd benchmark: linearly dense quartic inputs . | train | false |
37,721 | def GenerateIndexFromHistory(query_history, all_indexes=None, manual_indexes=None):
all_keys = datastore_index.IndexDefinitionsToKeys(all_indexes)
manual_keys = datastore_index.IndexDefinitionsToKeys(manual_indexes)
indexes = dict(((key, 0) for key in (all_keys - manual_keys)))
for (query, count) in query_history.iteritems():
(required, kind, ancestor, props) = datastore_index.CompositeIndexForQuery(query)
if required:
props = datastore_index.GetRecommendedIndexProperties(props)
key = (kind, ancestor, props)
if (key not in manual_keys):
if (key in indexes):
indexes[key] += count
else:
indexes[key] = count
if (not indexes):
return ''
res = []
for ((kind, ancestor, props), count) in sorted(indexes.iteritems()):
res.append('')
res.append(datastore_index.IndexYamlForQuery(kind, ancestor, props))
res.append('')
return '\n'.join(res)
| [
"def",
"GenerateIndexFromHistory",
"(",
"query_history",
",",
"all_indexes",
"=",
"None",
",",
"manual_indexes",
"=",
"None",
")",
":",
"all_keys",
"=",
"datastore_index",
".",
"IndexDefinitionsToKeys",
"(",
"all_indexes",
")",
"manual_keys",
"=",
"datastore_index",
... | generate most of the text for index . | train | false |
37,722 | @pytest.fixture
def x509_data():
pkey = PKey()
pkey.generate_key(TYPE_RSA, 384)
req = X509Req()
req.set_pubkey(pkey)
req.get_subject().commonName = 'Yoda root CA'
x509 = X509()
subject = x509.get_subject()
subject.commonName = req.get_subject().commonName
x509.set_issuer(subject)
x509.set_pubkey(pkey)
now = datetime.now()
expire = (datetime.now() + timedelta(days=100))
x509.set_notBefore(now.strftime('%Y%m%d%H%M%SZ').encode())
x509.set_notAfter(expire.strftime('%Y%m%d%H%M%SZ').encode())
(yield (pkey, x509))
| [
"@",
"pytest",
".",
"fixture",
"def",
"x509_data",
"(",
")",
":",
"pkey",
"=",
"PKey",
"(",
")",
"pkey",
".",
"generate_key",
"(",
"TYPE_RSA",
",",
"384",
")",
"req",
"=",
"X509Req",
"(",
")",
"req",
".",
"set_pubkey",
"(",
"pkey",
")",
"req",
".",... | create a new private key and start a certificate request . | train | false |
37,723 | def hexdecode(value):
value = value.lower()
return (value[2:] if value.startswith('0x') else value).decode('hex')
| [
"def",
"hexdecode",
"(",
"value",
")",
":",
"value",
"=",
"value",
".",
"lower",
"(",
")",
"return",
"(",
"value",
"[",
"2",
":",
"]",
"if",
"value",
".",
"startswith",
"(",
"'0x'",
")",
"else",
"value",
")",
".",
"decode",
"(",
"'hex'",
")"
] | decodes string value from hex to plain format . | train | false |
37,729 | def splitwords(s):
if (not s):
return []
return filter(bool, map(str.strip, re.split('[ ,\n]+', s)))
| [
"def",
"splitwords",
"(",
"s",
")",
":",
"if",
"(",
"not",
"s",
")",
":",
"return",
"[",
"]",
"return",
"filter",
"(",
"bool",
",",
"map",
"(",
"str",
".",
"strip",
",",
"re",
".",
"split",
"(",
"'[ ,\\n]+'",
",",
"s",
")",
")",
")"
] | helper to split words on any comma . | train | false |
37,730 | def removeBackupFilesByTypes(fileTypes):
for fileType in fileTypes:
removeBackupFilesByType(fileType)
| [
"def",
"removeBackupFilesByTypes",
"(",
"fileTypes",
")",
":",
"for",
"fileType",
"in",
"fileTypes",
":",
"removeBackupFilesByType",
"(",
"fileType",
")"
] | remove backup files by types . | train | false |
37,732 | def _check_location_uri(context, store_api, store_utils, uri):
try:
is_ok = (store_utils.validate_external_location(uri) and (store_api.get_size_from_backend(uri, context=context) > 0))
except (store.UnknownScheme, store.NotFound, store.BadStoreUri):
is_ok = False
if (not is_ok):
reason = _('Invalid location')
raise exception.BadStoreUri(message=reason)
| [
"def",
"_check_location_uri",
"(",
"context",
",",
"store_api",
",",
"store_utils",
",",
"uri",
")",
":",
"try",
":",
"is_ok",
"=",
"(",
"store_utils",
".",
"validate_external_location",
"(",
"uri",
")",
"and",
"(",
"store_api",
".",
"get_size_from_backend",
"... | check if an image location is valid . | train | false |
37,739 | def validate_string_or_none(option, value):
if (value is None):
return value
return validate_string(option, value)
| [
"def",
"validate_string_or_none",
"(",
"option",
",",
"value",
")",
":",
"if",
"(",
"value",
"is",
"None",
")",
":",
"return",
"value",
"return",
"validate_string",
"(",
"option",
",",
"value",
")"
] | validates that value is an instance of basestring or none . | train | false |
37,740 | def sensitivity(classify=(lambda document: False), documents=[]):
return recall(classify, document, average=None)
| [
"def",
"sensitivity",
"(",
"classify",
"=",
"(",
"lambda",
"document",
":",
"False",
")",
",",
"documents",
"=",
"[",
"]",
")",
":",
"return",
"recall",
"(",
"classify",
",",
"document",
",",
"average",
"=",
"None",
")"
] | returns the percentage of positive cases correctly classified as positive . | train | false |
37,741 | def hypermedia_in():
ct_in_map = {'application/x-www-form-urlencoded': urlencoded_processor, 'application/json': json_processor, 'application/x-yaml': yaml_processor, 'text/yaml': yaml_processor, 'text/plain': text_processor}
if ((cherrypy.request.method.upper() == 'POST') and (cherrypy.request.headers.get('Content-Length', '0') == '0')):
cherrypy.request.process_request_body = False
cherrypy.request.unserialized_data = None
cherrypy.request.body.processors.clear()
cherrypy.request.body.default_proc = cherrypy.HTTPError(406, 'Content type not supported')
cherrypy.request.body.processors = ct_in_map
| [
"def",
"hypermedia_in",
"(",
")",
":",
"ct_in_map",
"=",
"{",
"'application/x-www-form-urlencoded'",
":",
"urlencoded_processor",
",",
"'application/json'",
":",
"json_processor",
",",
"'application/x-yaml'",
":",
"yaml_processor",
",",
"'text/yaml'",
":",
"yaml_processor... | unserialize post/put data of a specified content-type . | train | true |
37,742 | def _make_requires(flag, error):
def _requires_decorator(func):
if (not flag):
@wraps(func)
def explode(*args, **kwargs):
raise NotImplementedError(error)
return explode
else:
return func
return _requires_decorator
| [
"def",
"_make_requires",
"(",
"flag",
",",
"error",
")",
":",
"def",
"_requires_decorator",
"(",
"func",
")",
":",
"if",
"(",
"not",
"flag",
")",
":",
"@",
"wraps",
"(",
"func",
")",
"def",
"explode",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":"... | builds a decorator that ensures that functions that rely on openssl functions that are not present in this build raise notimplementederror . | train | true |
37,744 | @task(base=BaseInstructorTask)
def proctored_exam_results_csv(entry_id, xmodule_instance_args):
action_name = 'generating_proctored_exam_results_report'
task_fn = partial(upload_proctored_exam_results_report, xmodule_instance_args)
return run_main_task(entry_id, task_fn, action_name)
| [
"@",
"task",
"(",
"base",
"=",
"BaseInstructorTask",
")",
"def",
"proctored_exam_results_csv",
"(",
"entry_id",
",",
"xmodule_instance_args",
")",
":",
"action_name",
"=",
"'generating_proctored_exam_results_report'",
"task_fn",
"=",
"partial",
"(",
"upload_proctored_exam... | compute proctored exam results report for a course and upload the csv for download . | train | false |
37,746 | def _deterministic_vector_sign_flip(u):
max_abs_rows = np.argmax(np.abs(u), axis=1)
signs = np.sign(u[(range(u.shape[0]), max_abs_rows)])
u *= signs[:, np.newaxis]
return u
| [
"def",
"_deterministic_vector_sign_flip",
"(",
"u",
")",
":",
"max_abs_rows",
"=",
"np",
".",
"argmax",
"(",
"np",
".",
"abs",
"(",
"u",
")",
",",
"axis",
"=",
"1",
")",
"signs",
"=",
"np",
".",
"sign",
"(",
"u",
"[",
"(",
"range",
"(",
"u",
".",... | modify the sign of vectors for reproducibility flips the sign of elements of all the vectors such that the absolute maximum element of each vector is positive . | train | false |
37,747 | def remove_challenge_for_url(url):
if (not url):
raise ValueError('URL cannot be empty')
url = parse.urlparse(url)
del _cache[url.netloc]
| [
"def",
"remove_challenge_for_url",
"(",
"url",
")",
":",
"if",
"(",
"not",
"url",
")",
":",
"raise",
"ValueError",
"(",
"'URL cannot be empty'",
")",
"url",
"=",
"parse",
".",
"urlparse",
"(",
"url",
")",
"del",
"_cache",
"[",
"url",
".",
"netloc",
"]"
] | removes the cached challenge for the specified url . | train | false |
37,748 | def total_size(o, handlers={}, verbose=False):
def dict_handler(d):
return chain.from_iterable(d.items())
all_handlers = {tuple: iter, list: iter, deque: iter, dict: dict_handler, set: iter, frozenset: iter}
all_handlers.update(handlers)
seen = set()
default_size = getsizeof(0)
def sizeof(o):
if (id(o) in seen):
return 0
seen.add(id(o))
s = getsizeof(o, default_size)
for (typ, handler) in all_handlers.items():
if isinstance(o, typ):
s += sum(map(sizeof, handler(o)))
break
return s
return sizeof(o)
| [
"def",
"total_size",
"(",
"o",
",",
"handlers",
"=",
"{",
"}",
",",
"verbose",
"=",
"False",
")",
":",
"def",
"dict_handler",
"(",
"d",
")",
":",
"return",
"chain",
".",
"from_iterable",
"(",
"d",
".",
"items",
"(",
")",
")",
"all_handlers",
"=",
"... | returns the approximate memory footprint an object and all of its contents . | train | true |
37,749 | def generate_addon_user_and_category(addon, user, category):
AddonUser.objects.create(addon=addon, user=user)
AddonCategory.objects.create(addon=addon, category=category, feature=True)
| [
"def",
"generate_addon_user_and_category",
"(",
"addon",
",",
"user",
",",
"category",
")",
":",
"AddonUser",
".",
"objects",
".",
"create",
"(",
"addon",
"=",
"addon",
",",
"user",
"=",
"user",
")",
"AddonCategory",
".",
"objects",
".",
"create",
"(",
"ad... | generate the dedicated addonuser and addoncategory for the given addon and user . | train | false |
37,750 | def pause_all():
global PAUSED_ALL
PAUSED_ALL = True
Downloader.do.pause()
logging.debug('PAUSED_ALL active')
| [
"def",
"pause_all",
"(",
")",
":",
"global",
"PAUSED_ALL",
"PAUSED_ALL",
"=",
"True",
"Downloader",
".",
"do",
".",
"pause",
"(",
")",
"logging",
".",
"debug",
"(",
"'PAUSED_ALL active'",
")"
] | pause all activities than cause disk access . | train | false |
37,751 | @contextmanager
def log_timing(logger, task, level=logging.INFO, final_msg=None, callbacks=None):
start = datetime.datetime.now()
if (task is not None):
logger.log(level, (str(task) + '...'))
(yield)
end = datetime.datetime.now()
delta = (end - start)
total = total_seconds(delta)
if (total < 60):
delta_str = ('%f seconds' % total)
else:
delta_str = str(delta)
if (final_msg is None):
logger.log(level, (str(task) + (' done. Time elapsed: %s' % delta_str)))
else:
logger.log(level, ' '.join((final_msg, delta_str)))
if (callbacks is not None):
for callback in callbacks:
callback(total)
| [
"@",
"contextmanager",
"def",
"log_timing",
"(",
"logger",
",",
"task",
",",
"level",
"=",
"logging",
".",
"INFO",
",",
"final_msg",
"=",
"None",
",",
"callbacks",
"=",
"None",
")",
":",
"start",
"=",
"datetime",
".",
"datetime",
".",
"now",
"(",
")",
... | context manager that logs the start/end of an operation . | train | false |
37,753 | def requires_special_home_display(name):
return ((name == '~') and Color.HOME_SPECIAL_DISPLAY)
| [
"def",
"requires_special_home_display",
"(",
"name",
")",
":",
"return",
"(",
"(",
"name",
"==",
"'~'",
")",
"and",
"Color",
".",
"HOME_SPECIAL_DISPLAY",
")"
] | returns true if the given directory name matches the home indicator and the chosen theme should use a special home indicator display . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.