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 |
|---|---|---|---|---|---|
50,195 | def makePersonalServerFactory(site):
return pb.PBServerFactory(distrib.ResourcePublisher(site))
| [
"def",
"makePersonalServerFactory",
"(",
"site",
")",
":",
"return",
"pb",
".",
"PBServerFactory",
"(",
"distrib",
".",
"ResourcePublisher",
"(",
"site",
")",
")"
] | create and return a factory which will respond to i{distrib} requests against the given site . | train | false |
50,196 | def a_to_s(A):
strs = []
for row in A:
x = ([None] * len(row))
for (i, num) in enumerate(row):
if (num != 0):
x[i] = '@'
else:
x[i] = ' '
strs.append(''.join(x))
return '\n'.join(strs)
| [
"def",
"a_to_s",
"(",
"A",
")",
":",
"strs",
"=",
"[",
"]",
"for",
"row",
"in",
"A",
":",
"x",
"=",
"(",
"[",
"None",
"]",
"*",
"len",
"(",
"row",
")",
")",
"for",
"(",
"i",
",",
"num",
")",
"in",
"enumerate",
"(",
"row",
")",
":",
"if",
... | prints binary array . | train | false |
50,197 | def _get_blobs(im, rois):
blobs = {'data': None, 'rois': None}
(blobs['data'], im_scale_factors) = _get_image_blob(im)
blobs['rois'] = _get_rois_blob(rois, im_scale_factors)
return (blobs, im_scale_factors)
| [
"def",
"_get_blobs",
"(",
"im",
",",
"rois",
")",
":",
"blobs",
"=",
"{",
"'data'",
":",
"None",
",",
"'rois'",
":",
"None",
"}",
"(",
"blobs",
"[",
"'data'",
"]",
",",
"im_scale_factors",
")",
"=",
"_get_image_blob",
"(",
"im",
")",
"blobs",
"[",
... | convert an image and rois within that image into network inputs . | train | false |
50,199 | def available_extensions(user=None, host=None, port=None, maintenance_db=None, password=None, runas=None):
exts = []
query = 'select * from pg_available_extensions();'
ret = psql_query(query, user=user, host=host, port=port, maintenance_db=maintenance_db, password=password, runas=runas)
exts = {}
for row in ret:
if (('default_version' in row) and ('name' in row)):
exts[row['name']] = row
return exts
| [
"def",
"available_extensions",
"(",
"user",
"=",
"None",
",",
"host",
"=",
"None",
",",
"port",
"=",
"None",
",",
"maintenance_db",
"=",
"None",
",",
"password",
"=",
"None",
",",
"runas",
"=",
"None",
")",
":",
"exts",
"=",
"[",
"]",
"query",
"=",
... | list available postgresql extensions cli example: . | train | true |
50,200 | def test_box():
(vertices, filled, outline) = create_box()
assert_array_equal(np.arange(len(vertices)), np.unique(filled))
assert_array_equal(np.arange(len(vertices)), np.unique(outline))
| [
"def",
"test_box",
"(",
")",
":",
"(",
"vertices",
",",
"filled",
",",
"outline",
")",
"=",
"create_box",
"(",
")",
"assert_array_equal",
"(",
"np",
".",
"arange",
"(",
"len",
"(",
"vertices",
")",
")",
",",
"np",
".",
"unique",
"(",
"filled",
")",
... | test box function . | train | false |
50,201 | def init_save_key(key_size, key_dir, keyname='key-certbot.pem'):
try:
key_pem = make_key(key_size)
except ValueError as err:
logger.exception(err)
raise err
config = zope.component.getUtility(interfaces.IConfig)
util.make_or_verify_dir(key_dir, 448, os.geteuid(), config.strict_permissions)
(key_f, key_path) = util.unique_file(os.path.join(key_dir, keyname), 384, 'wb')
with key_f:
key_f.write(key_pem)
logger.info('Generating key (%d bits): %s', key_size, key_path)
return util.Key(key_path, key_pem)
| [
"def",
"init_save_key",
"(",
"key_size",
",",
"key_dir",
",",
"keyname",
"=",
"'key-certbot.pem'",
")",
":",
"try",
":",
"key_pem",
"=",
"make_key",
"(",
"key_size",
")",
"except",
"ValueError",
"as",
"err",
":",
"logger",
".",
"exception",
"(",
"err",
")"... | initializes and saves a privkey . | train | false |
50,202 | def concat_all(*args):
if (len(args) != 1):
return concat_all(list(args))
if (not isinstance(args[0], (tuple, list))):
return [args[0]]
res = []
for k in args[0]:
res.extend(concat_all(k))
return res
| [
"def",
"concat_all",
"(",
"*",
"args",
")",
":",
"if",
"(",
"len",
"(",
"args",
")",
"!=",
"1",
")",
":",
"return",
"concat_all",
"(",
"list",
"(",
"args",
")",
")",
"if",
"(",
"not",
"isinstance",
"(",
"args",
"[",
"0",
"]",
",",
"(",
"tuple",... | concat_all -> list concats all the arguments together . | train | false |
50,203 | @aborts
@with_settings(foo=set())
def test_require_key_exists_empty_set():
require('foo')
| [
"@",
"aborts",
"@",
"with_settings",
"(",
"foo",
"=",
"set",
"(",
")",
")",
"def",
"test_require_key_exists_empty_set",
"(",
")",
":",
"require",
"(",
"'foo'",
")"
] | when given a single existing key but the value is an empty set . | train | false |
50,204 | def _kwargs_to_nodes(kwargs):
node = (kwargs.get('node') or kwargs.get('project'))
parent = kwargs.get('parent')
if node:
return (parent, node)
pid = kwargs.get('pid')
nid = kwargs.get('nid')
if (pid and nid):
node = _load_node_or_fail(nid)
parent = _load_node_or_fail(pid)
elif (pid and (not nid)):
node = _load_node_or_fail(pid)
elif (nid and (not pid)):
node = _load_node_or_fail(nid)
elif ((not pid) and (not nid)):
raise HTTPError(http.NOT_FOUND, data={'message_short': 'Node not found', 'message_long': 'No Node with that primary key could be found'})
return (parent, node)
| [
"def",
"_kwargs_to_nodes",
"(",
"kwargs",
")",
":",
"node",
"=",
"(",
"kwargs",
".",
"get",
"(",
"'node'",
")",
"or",
"kwargs",
".",
"get",
"(",
"'project'",
")",
")",
"parent",
"=",
"kwargs",
".",
"get",
"(",
"'parent'",
")",
"if",
"node",
":",
"r... | retrieve project and component objects from keyword arguments . | train | false |
50,205 | def _get_dev_url(backend, instance=None):
return ('http://%s' % _get_dev_hostname(backend, instance))
| [
"def",
"_get_dev_url",
"(",
"backend",
",",
"instance",
"=",
"None",
")",
":",
"return",
"(",
"'http://%s'",
"%",
"_get_dev_hostname",
"(",
"backend",
",",
"instance",
")",
")"
] | returns the url of a backend [instance] in the dev_appserver . | train | false |
50,206 | def parse_row(input_row, parsers):
return [(parser(value) if (parser is not None) else value) for (value, parser) in zip(input_row, parsers)]
| [
"def",
"parse_row",
"(",
"input_row",
",",
"parsers",
")",
":",
"return",
"[",
"(",
"parser",
"(",
"value",
")",
"if",
"(",
"parser",
"is",
"not",
"None",
")",
"else",
"value",
")",
"for",
"(",
"value",
",",
"parser",
")",
"in",
"zip",
"(",
"input_... | given a list of parsers apply the appropriate one to each element of the input_row . | train | false |
50,208 | def extract_zip(source, remove=False, fatal=True):
tempdir = tempfile.mkdtemp()
zip_file = SafeUnzip(source)
try:
if zip_file.is_valid(fatal):
zip_file.extract_to_dest(tempdir)
except:
rm_local_tmp_dir(tempdir)
raise
if remove:
os.remove(source)
return tempdir
| [
"def",
"extract_zip",
"(",
"source",
",",
"remove",
"=",
"False",
",",
"fatal",
"=",
"True",
")",
":",
"tempdir",
"=",
"tempfile",
".",
"mkdtemp",
"(",
")",
"zip_file",
"=",
"SafeUnzip",
"(",
"source",
")",
"try",
":",
"if",
"zip_file",
".",
"is_valid"... | extracts the zip file . | train | false |
50,209 | def false_():
return False
| [
"def",
"false_",
"(",
")",
":",
"return",
"False"
] | always return false cli example: . | train | false |
50,211 | def ode_nth_linear_constant_coeff_variation_of_parameters(eq, func, order, match):
gensol = ode_nth_linear_constant_coeff_homogeneous(eq, func, order, match, returns='both')
match.update(gensol)
return _solve_variation_of_parameters(eq, func, order, match)
| [
"def",
"ode_nth_linear_constant_coeff_variation_of_parameters",
"(",
"eq",
",",
"func",
",",
"order",
",",
"match",
")",
":",
"gensol",
"=",
"ode_nth_linear_constant_coeff_homogeneous",
"(",
"eq",
",",
"func",
",",
"order",
",",
"match",
",",
"returns",
"=",
"'bot... | solves an nth order linear differential equation with constant coefficients using the method of variation of parameters . | train | false |
50,212 | def db_del_user(username):
user = get_object(User, username=username)
if user:
user.delete()
| [
"def",
"db_del_user",
"(",
"username",
")",
":",
"user",
"=",
"get_object",
"(",
"User",
",",
"username",
"=",
"username",
")",
"if",
"user",
":",
"user",
".",
"delete",
"(",
")"
] | delete a user from database . | train | false |
50,213 | def _removeBackrefs(senderkey):
try:
signals = connections[senderkey]
except KeyError:
signals = None
else:
items = signals.items()
def allReceivers():
for (signal, set) in items:
for item in set:
(yield item)
for receiver in allReceivers():
_killBackref(receiver, senderkey)
| [
"def",
"_removeBackrefs",
"(",
"senderkey",
")",
":",
"try",
":",
"signals",
"=",
"connections",
"[",
"senderkey",
"]",
"except",
"KeyError",
":",
"signals",
"=",
"None",
"else",
":",
"items",
"=",
"signals",
".",
"items",
"(",
")",
"def",
"allReceivers",
... | remove all back-references to this senderkey . | train | true |
50,214 | def test_indentation():
count = 40
gotoutput = pretty.pretty(MyList(range(count)))
expectedoutput = (('MyList(\n' + ',\n'.join(((' %d' % i) for i in range(count)))) + ')')
nt.assert_equal(gotoutput, expectedoutput)
| [
"def",
"test_indentation",
"(",
")",
":",
"count",
"=",
"40",
"gotoutput",
"=",
"pretty",
".",
"pretty",
"(",
"MyList",
"(",
"range",
"(",
"count",
")",
")",
")",
"expectedoutput",
"=",
"(",
"(",
"'MyList(\\n'",
"+",
"',\\n'",
".",
"join",
"(",
"(",
... | test correct indentation in groups . | train | false |
50,215 | def runWithConfig(swarmConfig, options, outDir=None, outputLabel='default', permWorkDir=None, verbosity=1):
global g_currentVerbosityLevel
g_currentVerbosityLevel = verbosity
if (outDir is None):
outDir = os.getcwd()
if (permWorkDir is None):
permWorkDir = os.getcwd()
_checkOverwrite(options, outDir)
_generateExpFilesFromSwarmDescription(swarmConfig, outDir)
options['expDescConfig'] = swarmConfig
options['outputLabel'] = outputLabel
options['outDir'] = outDir
options['permWorkDir'] = permWorkDir
runOptions = _injectDefaultOptions(options)
_validateOptions(runOptions)
return _runAction(runOptions)
| [
"def",
"runWithConfig",
"(",
"swarmConfig",
",",
"options",
",",
"outDir",
"=",
"None",
",",
"outputLabel",
"=",
"'default'",
",",
"permWorkDir",
"=",
"None",
",",
"verbosity",
"=",
"1",
")",
":",
"global",
"g_currentVerbosityLevel",
"g_currentVerbosityLevel",
"... | starts a swarm . | train | true |
50,217 | def get_page_context(page, content, toc, meta, config):
if config[u'site_url']:
page.set_canonical_url(config[u'site_url'])
if config[u'repo_url']:
page.set_edit_url(config[u'repo_url'], config[u'edit_uri'])
page.content = content
page.toc = toc
page.meta = meta
if (page.is_homepage or (page.title is None)):
page_title = None
else:
page_title = page.title
if page.is_homepage:
page_description = config[u'site_description']
else:
page_description = None
return {u'page': page, u'page_title': page_title, u'page_description': page_description, u'content': content, u'toc': toc, u'meta': meta, u'canonical_url': page.canonical_url, u'current_page': page, u'previous_page': page.previous_page, u'next_page': page.next_page}
| [
"def",
"get_page_context",
"(",
"page",
",",
"content",
",",
"toc",
",",
"meta",
",",
"config",
")",
":",
"if",
"config",
"[",
"u'site_url'",
"]",
":",
"page",
".",
"set_canonical_url",
"(",
"config",
"[",
"u'site_url'",
"]",
")",
"if",
"config",
"[",
... | generate the page context by extending the global context and adding page specific variables . | train | false |
50,218 | @RegisterWithArgChecks(name='neighbor.in_filter.set', req_args=[neighbors.IP_ADDRESS, neighbors.IN_FILTER])
def set_neighbor_in_filter(neigh_ip_address, filters):
core = CORE_MANAGER.get_core_service()
peer = core.peer_manager.get_by_addr(neigh_ip_address)
peer.in_filters = filters
return True
| [
"@",
"RegisterWithArgChecks",
"(",
"name",
"=",
"'neighbor.in_filter.set'",
",",
"req_args",
"=",
"[",
"neighbors",
".",
"IP_ADDRESS",
",",
"neighbors",
".",
"IN_FILTER",
"]",
")",
"def",
"set_neighbor_in_filter",
"(",
"neigh_ip_address",
",",
"filters",
")",
":",... | returns a neighbor in_filter for given ip address if exists . | train | false |
50,220 | def create_cache(size):
if (size == 0):
return None
if (size < 0):
return {}
return LRUCache(size)
| [
"def",
"create_cache",
"(",
"size",
")",
":",
"if",
"(",
"size",
"==",
"0",
")",
":",
"return",
"None",
"if",
"(",
"size",
"<",
"0",
")",
":",
"return",
"{",
"}",
"return",
"LRUCache",
"(",
"size",
")"
] | return the cache class for the given size . | train | false |
50,221 | def isLoopListIntersecting(loops):
for loopIndex in xrange((len(loops) - 1)):
loop = loops[loopIndex]
if isLoopIntersectingLoops(loop, loops[(loopIndex + 1):]):
return True
return False
| [
"def",
"isLoopListIntersecting",
"(",
"loops",
")",
":",
"for",
"loopIndex",
"in",
"xrange",
"(",
"(",
"len",
"(",
"loops",
")",
"-",
"1",
")",
")",
":",
"loop",
"=",
"loops",
"[",
"loopIndex",
"]",
"if",
"isLoopIntersectingLoops",
"(",
"loop",
",",
"l... | determine if a loop in the list is intersecting the other loops . | train | false |
50,222 | def test_multiseries_donut():
chart = Pie(inner_radius=0.3, pretty_print=True)
chart.title = 'Browser usage by version in February 2012 (in %)'
chart.add('IE', [5.7, 10.2, 2.6, 1])
chart.add('Firefox', [0.6, 16.8, 7.4, 2.2, 1.2, 1, 1, 1.1, 4.3, 1])
chart.add('Chrome', [0.3, 0.9, 17.1, 15.3, 0.6, 0.5, 1.6])
chart.add('Safari', [4.4, 0.1])
chart.add('Opera', [0.1, 1.6, 0.1, 0.5])
assert chart.render()
| [
"def",
"test_multiseries_donut",
"(",
")",
":",
"chart",
"=",
"Pie",
"(",
"inner_radius",
"=",
"0.3",
",",
"pretty_print",
"=",
"True",
")",
"chart",
".",
"title",
"=",
"'Browser usage by version in February 2012 (in %)'",
"chart",
".",
"add",
"(",
"'IE'",
",",
... | test a donut pie chart with multiserie . | train | false |
50,223 | def from_bytes(klass, data):
obj = klass()
b = TMemoryBuffer(data)
p = TBinaryProtocol(b)
obj.read(p)
return obj
| [
"def",
"from_bytes",
"(",
"klass",
",",
"data",
")",
":",
"obj",
"=",
"klass",
"(",
")",
"b",
"=",
"TMemoryBuffer",
"(",
"data",
")",
"p",
"=",
"TBinaryProtocol",
"(",
"b",
")",
"obj",
".",
"read",
"(",
"p",
")",
"return",
"obj"
] | returns thrift object from a string . | train | false |
50,226 | def render_template_multiple_times(request):
return HttpResponse((render_to_string('base.html') + render_to_string('base.html')))
| [
"def",
"render_template_multiple_times",
"(",
"request",
")",
":",
"return",
"HttpResponse",
"(",
"(",
"render_to_string",
"(",
"'base.html'",
")",
"+",
"render_to_string",
"(",
"'base.html'",
")",
")",
")"
] | a view that renders a template multiple times . | train | false |
50,228 | def remote(expr):
return _annotate_columns(expression._clause_element_as_expr(expr), {'remote': True})
| [
"def",
"remote",
"(",
"expr",
")",
":",
"return",
"_annotate_columns",
"(",
"expression",
".",
"_clause_element_as_expr",
"(",
"expr",
")",
",",
"{",
"'remote'",
":",
"True",
"}",
")"
] | annotate a portion of a primaryjoin expression with a remote annotation . | train | false |
50,229 | def get_models(app_labels):
from django.db.models import get_app, get_apps, get_model
from django.db.models import get_models as get_all_models
from django.contrib.contenttypes.models import ContentType
EXCLUDED_MODELS = (ContentType,)
models = []
if (not app_labels):
for app in get_apps():
models += [m for m in get_all_models(app) if (m not in EXCLUDED_MODELS)]
for app_label in app_labels:
if ('.' in app_label):
(app_label, model_name) = app_label.split('.', 1)
models.append(get_model(app_label, model_name))
else:
models += [m for m in get_all_models(get_app(app_label)) if (m not in EXCLUDED_MODELS)]
return models
| [
"def",
"get_models",
"(",
"app_labels",
")",
":",
"from",
"django",
".",
"db",
".",
"models",
"import",
"get_app",
",",
"get_apps",
",",
"get_model",
"from",
"django",
".",
"db",
".",
"models",
"import",
"get_models",
"as",
"get_all_models",
"from",
"django"... | gets a list of models for the given app labels . | train | false |
50,230 | def yaml_dquote(text):
with io.StringIO() as ostream:
yemitter = yaml.emitter.Emitter(ostream, width=six.MAXSIZE)
yemitter.write_double_quoted(six.text_type(text))
return ostream.getvalue()
| [
"def",
"yaml_dquote",
"(",
"text",
")",
":",
"with",
"io",
".",
"StringIO",
"(",
")",
"as",
"ostream",
":",
"yemitter",
"=",
"yaml",
".",
"emitter",
".",
"Emitter",
"(",
"ostream",
",",
"width",
"=",
"six",
".",
"MAXSIZE",
")",
"yemitter",
".",
"writ... | make text into a double-quoted yaml string with correct escaping for special characters . | train | true |
50,231 | def safe_quote(s):
return (urllib.quote(s) if (s == urllib.unquote(s)) else s)
| [
"def",
"safe_quote",
"(",
"s",
")",
":",
"return",
"(",
"urllib",
".",
"quote",
"(",
"s",
")",
"if",
"(",
"s",
"==",
"urllib",
".",
"unquote",
"(",
"s",
")",
")",
"else",
"s",
")"
] | url-encode strings that are not already url-encoded . | train | false |
50,232 | def slugify_uniquely(value, model, slugfield='slug'):
suffix = 0
potential = base = django_slugify(unidecode(value))
if (len(potential) == 0):
potential = 'null'
while True:
if suffix:
potential = '-'.join([base, str(suffix)])
if (not model.objects.filter(**{slugfield: potential}).exists()):
return potential
suffix += 1
| [
"def",
"slugify_uniquely",
"(",
"value",
",",
"model",
",",
"slugfield",
"=",
"'slug'",
")",
":",
"suffix",
"=",
"0",
"potential",
"=",
"base",
"=",
"django_slugify",
"(",
"unidecode",
"(",
"value",
")",
")",
"if",
"(",
"len",
"(",
"potential",
")",
"=... | returns a slug on a name which is unique within a models table . | train | false |
50,233 | def no_auth_required(fn):
fn._no_auth_required = True
return fn
| [
"def",
"no_auth_required",
"(",
"fn",
")",
":",
"fn",
".",
"_no_auth_required",
"=",
"True",
"return",
"fn"
] | authentication is not required to use the given method . | train | false |
50,236 | def gaussian_random_partition_graph(n, s, v, p_in, p_out, directed=False, seed=None):
if (s > n):
raise nx.NetworkXError('s must be <= n')
assigned = 0
sizes = []
while True:
size = int(random.normalvariate(s, ((float(s) / v) + 0.5)))
if (size < 1):
continue
if ((assigned + size) >= n):
sizes.append((n - assigned))
break
assigned += size
sizes.append(size)
return random_partition_graph(sizes, p_in, p_out, directed, seed)
| [
"def",
"gaussian_random_partition_graph",
"(",
"n",
",",
"s",
",",
"v",
",",
"p_in",
",",
"p_out",
",",
"directed",
"=",
"False",
",",
"seed",
"=",
"None",
")",
":",
"if",
"(",
"s",
">",
"n",
")",
":",
"raise",
"nx",
".",
"NetworkXError",
"(",
"'s ... | generate a gaussian random partition graph . | train | false |
50,239 | def Newline():
return Leaf(token.NEWLINE, '\n')
| [
"def",
"Newline",
"(",
")",
":",
"return",
"Leaf",
"(",
"token",
".",
"NEWLINE",
",",
"'\\n'",
")"
] | a newline literal . | train | false |
50,240 | @step((CHECK_PREFIX + 'I have sent an email with the following in the body:'))
def mail_sent_content_multiline(step):
return mail_sent_content(step, step.multiline, 'body')
| [
"@",
"step",
"(",
"(",
"CHECK_PREFIX",
"+",
"'I have sent an email with the following in the body:'",
")",
")",
"def",
"mail_sent_content_multiline",
"(",
"step",
")",
":",
"return",
"mail_sent_content",
"(",
"step",
",",
"step",
".",
"multiline",
",",
"'body'",
")"... | i have sent an email with the following in the body: name: mr . | train | false |
50,241 | def award_program_certificate(client, username, program_uuid):
client.credentials.post({'username': username, 'credential': {'program_uuid': program_uuid}, 'attributes': []})
| [
"def",
"award_program_certificate",
"(",
"client",
",",
"username",
",",
"program_uuid",
")",
":",
"client",
".",
"credentials",
".",
"post",
"(",
"{",
"'username'",
":",
"username",
",",
"'credential'",
":",
"{",
"'program_uuid'",
":",
"program_uuid",
"}",
",... | issue a new certificate of completion to the given student for the given program . | train | false |
50,242 | def available_content_databases():
pattern = re.compile('content_(?P<channel>[^_]+)_(?P<language>[^_]+).sqlite')
for filename in glob.iglob(django_settings.DEFAULT_DATABASE_DIR):
match = pattern.search(filename)
if match:
(yield match.group(1, 2))
| [
"def",
"available_content_databases",
"(",
")",
":",
"pattern",
"=",
"re",
".",
"compile",
"(",
"'content_(?P<channel>[^_]+)_(?P<language>[^_]+).sqlite'",
")",
"for",
"filename",
"in",
"glob",
".",
"iglob",
"(",
"django_settings",
".",
"DEFAULT_DATABASE_DIR",
")",
":"... | generator to return the channel and language for every content database that exists in the system . | train | false |
50,244 | def init(mpstate):
return SerialModule(mpstate)
| [
"def",
"init",
"(",
"mpstate",
")",
":",
"return",
"SerialModule",
"(",
"mpstate",
")"
] | initialise module . | train | false |
50,245 | def filter_roidb(roidb):
def is_valid(entry):
overlaps = entry['max_overlaps']
fg_inds = np.where((overlaps >= cfg.TRAIN.FG_THRESH))[0]
bg_inds = np.where(((overlaps < cfg.TRAIN.BG_THRESH_HI) & (overlaps >= cfg.TRAIN.BG_THRESH_LO)))[0]
valid = ((len(fg_inds) > 0) or (len(bg_inds) > 0))
return valid
num = len(roidb)
filtered_roidb = [entry for entry in roidb if is_valid(entry)]
num_after = len(filtered_roidb)
print 'Filtered {} roidb entries: {} -> {}'.format((num - num_after), num, num_after)
return filtered_roidb
| [
"def",
"filter_roidb",
"(",
"roidb",
")",
":",
"def",
"is_valid",
"(",
"entry",
")",
":",
"overlaps",
"=",
"entry",
"[",
"'max_overlaps'",
"]",
"fg_inds",
"=",
"np",
".",
"where",
"(",
"(",
"overlaps",
">=",
"cfg",
".",
"TRAIN",
".",
"FG_THRESH",
")",
... | remove roidb entries that have no usable rois . | train | false |
50,246 | def logical_xor(image1, image2):
image1.load()
image2.load()
return image1._new(image1.im.chop_xor(image2.im))
| [
"def",
"logical_xor",
"(",
"image1",
",",
"image2",
")",
":",
"image1",
".",
"load",
"(",
")",
"image2",
".",
"load",
"(",
")",
"return",
"image1",
".",
"_new",
"(",
"image1",
".",
"im",
".",
"chop_xor",
"(",
"image2",
".",
"im",
")",
")"
] | logical xor between two images . | train | false |
50,247 | def case_insensitive_update(dct1, dct2):
lowkeys = dict([(key.lower(), key) for key in dct1])
for (key, val) in dct2.items():
d1_key = lowkeys.get(key.lower(), key)
dct1[d1_key] = val
| [
"def",
"case_insensitive_update",
"(",
"dct1",
",",
"dct2",
")",
":",
"lowkeys",
"=",
"dict",
"(",
"[",
"(",
"key",
".",
"lower",
"(",
")",
",",
"key",
")",
"for",
"key",
"in",
"dct1",
"]",
")",
"for",
"(",
"key",
",",
"val",
")",
"in",
"dct2",
... | given two dicts . | train | true |
50,248 | def get_threads(exploration_id):
thread_models = feedback_models.FeedbackThreadModel.get_threads(exploration_id)
return [_get_thread_from_model(model) for model in thread_models]
| [
"def",
"get_threads",
"(",
"exploration_id",
")",
":",
"thread_models",
"=",
"feedback_models",
".",
"FeedbackThreadModel",
".",
"get_threads",
"(",
"exploration_id",
")",
"return",
"[",
"_get_thread_from_model",
"(",
"model",
")",
"for",
"model",
"in",
"thread_mode... | fetches all the threads for the given exploration id . | train | false |
50,249 | @dec.skip_without('sqlite3')
def test_macro_run():
ip = get_ipython()
ip.history_manager.reset()
cmds = ['a=10', 'a+=1', py3compat.doctest_refactor_print('print a'), '%macro test 2-3']
for cmd in cmds:
ip.run_cell(cmd, store_history=True)
nt.assert_equal(ip.user_ns['test'].value, py3compat.doctest_refactor_print('a+=1\nprint a\n'))
with tt.AssertPrints('12'):
ip.run_cell('test')
with tt.AssertPrints('13'):
ip.run_cell('test')
| [
"@",
"dec",
".",
"skip_without",
"(",
"'sqlite3'",
")",
"def",
"test_macro_run",
"(",
")",
":",
"ip",
"=",
"get_ipython",
"(",
")",
"ip",
".",
"history_manager",
".",
"reset",
"(",
")",
"cmds",
"=",
"[",
"'a=10'",
",",
"'a+=1'",
",",
"py3compat",
".",
... | test that we can run a multi-line macro successfully . | train | false |
50,250 | def set_style(style=None, rc=None):
style_object = axes_style(style, rc)
mpl.rcParams.update(style_object)
| [
"def",
"set_style",
"(",
"style",
"=",
"None",
",",
"rc",
"=",
"None",
")",
":",
"style_object",
"=",
"axes_style",
"(",
"style",
",",
"rc",
")",
"mpl",
".",
"rcParams",
".",
"update",
"(",
"style_object",
")"
] | set the aesthetic style of the plots . | train | true |
50,251 | def subtractXIntersectionsTable(subtractFromTable, subtractTable):
subtractFromTableKeys = subtractFromTable.keys()
subtractFromTableKeys.sort()
for subtractFromTableKey in subtractFromTableKeys:
xIntersectionIndexList = []
addXIntersectionIndexesFromXIntersections((-1), xIntersectionIndexList, subtractFromTable[subtractFromTableKey])
if (subtractFromTableKey in subtractTable):
addXIntersectionIndexesFromXIntersections(0, xIntersectionIndexList, subtractTable[subtractFromTableKey])
xIntersections = getXIntersectionsFromIntersections(xIntersectionIndexList)
if (len(xIntersections) > 0):
subtractFromTable[subtractFromTableKey] = xIntersections
else:
del subtractFromTable[subtractFromTableKey]
| [
"def",
"subtractXIntersectionsTable",
"(",
"subtractFromTable",
",",
"subtractTable",
")",
":",
"subtractFromTableKeys",
"=",
"subtractFromTable",
".",
"keys",
"(",
")",
"subtractFromTableKeys",
".",
"sort",
"(",
")",
"for",
"subtractFromTableKey",
"in",
"subtractFromTa... | subtract the subtracttable from the subtractfromtable . | train | false |
50,252 | def ROCP(ds, count, timeperiod=(- (2 ** 31))):
return call_talib_with_ds(ds, count, talib.ROCP, timeperiod)
| [
"def",
"ROCP",
"(",
"ds",
",",
"count",
",",
"timeperiod",
"=",
"(",
"-",
"(",
"2",
"**",
"31",
")",
")",
")",
":",
"return",
"call_talib_with_ds",
"(",
"ds",
",",
"count",
",",
"talib",
".",
"ROCP",
",",
"timeperiod",
")"
] | rate of change percentage: /prevprice . | train | false |
50,253 | @register.filter
def app_label(obj):
try:
return lower(obj._meta.object_name)
except AttributeError:
return ''
| [
"@",
"register",
".",
"filter",
"def",
"app_label",
"(",
"obj",
")",
":",
"try",
":",
"return",
"lower",
"(",
"obj",
".",
"_meta",
".",
"object_name",
")",
"except",
"AttributeError",
":",
"return",
"''"
] | returns an objects app label . | train | false |
50,254 | def PackLocation(location):
packed = struct.pack('>ddd', *[float(x) for x in location])
return base64hex.B64HexEncode(packed)
| [
"def",
"PackLocation",
"(",
"location",
")",
":",
"packed",
"=",
"struct",
".",
"pack",
"(",
"'>ddd'",
",",
"*",
"[",
"float",
"(",
"x",
")",
"for",
"x",
"in",
"location",
"]",
")",
"return",
"base64hex",
".",
"B64HexEncode",
"(",
"packed",
")"
] | converts location named tuple into a packed . | train | false |
50,255 | def _is_epsilon_nash(x, g, epsilon, indptr=None):
if (indptr is None):
indptr = np.empty((g.N + 1), dtype=int)
indptr[0] = 0
indptr[1:] = np.cumsum(g.nums_actions)
action_profile = _get_action_profile(x, indptr)
return g.is_nash(action_profile, tol=epsilon)
| [
"def",
"_is_epsilon_nash",
"(",
"x",
",",
"g",
",",
"epsilon",
",",
"indptr",
"=",
"None",
")",
":",
"if",
"(",
"indptr",
"is",
"None",
")",
":",
"indptr",
"=",
"np",
".",
"empty",
"(",
"(",
"g",
".",
"N",
"+",
"1",
")",
",",
"dtype",
"=",
"i... | determine whether x is an epsilon-nash equilibrium of g . | train | true |
50,257 | def _property_name_to_value(entities):
return {key: values[0] for (key, values) in _property_name_to_values(entities).iteritems()}
| [
"def",
"_property_name_to_value",
"(",
"entities",
")",
":",
"return",
"{",
"key",
":",
"values",
"[",
"0",
"]",
"for",
"(",
"key",
",",
"values",
")",
"in",
"_property_name_to_values",
"(",
"entities",
")",
".",
"iteritems",
"(",
")",
"}"
] | returns a a mapping of entity property names to a sample value . | train | false |
50,259 | def event2json(event):
return jdumps(dict(type=event.type, send_event=event.send_event, time=event.time, root=str(event.root), window=str(event.window), same_screen=event.same_screen, child=str(event.child), root_x=event.root_x, root_y=event.root_y, event_x=event.event_x, event_y=event.event_y, state=event.state, detail=event.detail))
| [
"def",
"event2json",
"(",
"event",
")",
":",
"return",
"jdumps",
"(",
"dict",
"(",
"type",
"=",
"event",
".",
"type",
",",
"send_event",
"=",
"event",
".",
"send_event",
",",
"time",
"=",
"event",
".",
"time",
",",
"root",
"=",
"str",
"(",
"event",
... | instance variable: keybuttonpointerevent time the server x time when this event was generated . | train | false |
50,260 | def dummy_product(d1, d2, method='full'):
if (method == 'full'):
dd = (d1[:, :, None] * d2[:, None, :]).reshape(d1.shape[0], (-1))
elif (method == 'drop-last'):
d12rl = dummy_product(d1[:, :(-1)], d2[:, :(-1)])
dd = np.column_stack((np.ones(d1.shape[0], int), d1[:, :(-1)], d2[:, :(-1)], d12rl))
elif (method == 'drop-first'):
d12r = dummy_product(d1[:, 1:], d2[:, 1:])
dd = np.column_stack((np.ones(d1.shape[0], int), d1[:, 1:], d2[:, 1:], d12r))
else:
raise ValueError('method not recognized')
return dd
| [
"def",
"dummy_product",
"(",
"d1",
",",
"d2",
",",
"method",
"=",
"'full'",
")",
":",
"if",
"(",
"method",
"==",
"'full'",
")",
":",
"dd",
"=",
"(",
"d1",
"[",
":",
",",
":",
",",
"None",
"]",
"*",
"d2",
"[",
":",
",",
"None",
",",
":",
"]"... | dummy variable from product of two dummy variables parameters d1 . | train | false |
50,262 | def _iter_contrasts(n_subjects, factor_levels, effect_picks):
from scipy.signal import detrend
sc = []
n_factors = len(factor_levels)
for n_levels in factor_levels:
sc.append([np.ones([n_levels, 1]), detrend(np.eye(n_levels), type='constant')])
for this_effect in effect_picks:
contrast_idx = _get_contrast_indices((this_effect + 1), n_factors)
c_ = sc[0][contrast_idx[(n_factors - 1)]]
for i_contrast in range(1, n_factors):
this_contrast = contrast_idx[((n_factors - 1) - i_contrast)]
c_ = np.kron(c_, sc[i_contrast][this_contrast])
df1 = np.linalg.matrix_rank(c_)
df2 = (df1 * (n_subjects - 1))
(yield (c_, df1, df2))
| [
"def",
"_iter_contrasts",
"(",
"n_subjects",
",",
"factor_levels",
",",
"effect_picks",
")",
":",
"from",
"scipy",
".",
"signal",
"import",
"detrend",
"sc",
"=",
"[",
"]",
"n_factors",
"=",
"len",
"(",
"factor_levels",
")",
"for",
"n_levels",
"in",
"factor_l... | setup contrasts . | train | false |
50,264 | def membership():
redirect(URL(c='admin', args=request.args, vars=request.vars))
| [
"def",
"membership",
"(",
")",
":",
"redirect",
"(",
"URL",
"(",
"c",
"=",
"'admin'",
",",
"args",
"=",
"request",
".",
"args",
",",
"vars",
"=",
"request",
".",
"vars",
")",
")"
] | defined in admin module . | train | false |
50,265 | def _handle_following_field(form_value, user, cc_content):
if form_value:
user.follow(cc_content)
else:
user.unfollow(cc_content)
| [
"def",
"_handle_following_field",
"(",
"form_value",
",",
"user",
",",
"cc_content",
")",
":",
"if",
"form_value",
":",
"user",
".",
"follow",
"(",
"cc_content",
")",
"else",
":",
"user",
".",
"unfollow",
"(",
"cc_content",
")"
] | follow/unfollow thread for the user . | train | false |
50,270 | def _deprecateAttribute(proxy, name, version, message):
_module = object.__getattribute__(proxy, '_module')
attr = _DeprecatedAttribute(_module, name, version, message)
_deprecatedAttributes = object.__getattribute__(proxy, '_deprecatedAttributes')
_deprecatedAttributes[name] = attr
| [
"def",
"_deprecateAttribute",
"(",
"proxy",
",",
"name",
",",
"version",
",",
"message",
")",
":",
"_module",
"=",
"object",
".",
"__getattribute__",
"(",
"proxy",
",",
"'_module'",
")",
"attr",
"=",
"_DeprecatedAttribute",
"(",
"_module",
",",
"name",
",",
... | mark a module-level attribute as being deprecated . | train | false |
50,273 | def generate_auth_sub_url(next, scopes, secure=False, session=True, request_url='https://www.google.com/accounts/AuthSubRequest', domain='default', scopes_param_prefix='auth_sub_scopes'):
if isinstance(next, (str, unicode)):
next = atom.url.parse_url(next)
scopes_string = ' '.join([str(scope) for scope in scopes])
next.params[scopes_param_prefix] = scopes_string
if isinstance(request_url, (str, unicode)):
request_url = atom.url.parse_url(request_url)
request_url.params['next'] = str(next)
request_url.params['scope'] = scopes_string
if session:
request_url.params['session'] = 1
else:
request_url.params['session'] = 0
if secure:
request_url.params['secure'] = 1
else:
request_url.params['secure'] = 0
request_url.params['hd'] = domain
return request_url
| [
"def",
"generate_auth_sub_url",
"(",
"next",
",",
"scopes",
",",
"secure",
"=",
"False",
",",
"session",
"=",
"True",
",",
"request_url",
"=",
"'https://www.google.com/accounts/AuthSubRequest'",
",",
"domain",
"=",
"'default'",
",",
"scopes_param_prefix",
"=",
"'aut... | constructs a url string for requesting a multiscope authsub token . | train | false |
50,274 | def version_setting(parser, token):
try:
(tag, version_suffix) = token.split_contents()
except:
raise TemplateSyntaxError(('%s tag requires 1 argument' % token.contents.split()[0]))
if (((version_suffix[0] == version_suffix[(-1)]) and (version_suffix[0] in ('"', "'"))) and (version_suffix.lower()[1:(-1)] not in VERSIONS)):
raise TemplateSyntaxError(('%s tag received bad version_suffix %s' % (tag, version_suffix)))
return VersionSettingNode(version_suffix)
| [
"def",
"version_setting",
"(",
"parser",
",",
"token",
")",
":",
"try",
":",
"(",
"tag",
",",
"version_suffix",
")",
"=",
"token",
".",
"split_contents",
"(",
")",
"except",
":",
"raise",
"TemplateSyntaxError",
"(",
"(",
"'%s tag requires 1 argument'",
"%",
... | get information about a version setting . | train | false |
50,277 | @pytest.mark.network
def test_install_global_option_using_editable(script, tmpdir):
url = 'hg+http://bitbucket.org/runeh/anyjson'
result = script.pip('install', '--global-option=--version', '-e', ('%s@0.2.5#egg=anyjson' % local_checkout(url, tmpdir.join('cache'))), expect_stderr=True)
assert ('Successfully installed anyjson' in result.stdout)
| [
"@",
"pytest",
".",
"mark",
".",
"network",
"def",
"test_install_global_option_using_editable",
"(",
"script",
",",
"tmpdir",
")",
":",
"url",
"=",
"'hg+http://bitbucket.org/runeh/anyjson'",
"result",
"=",
"script",
".",
"pip",
"(",
"'install'",
",",
"'--global-opti... | test using global distutils options . | train | false |
50,280 | def do_scrape():
sc = SlackClient(settings.SLACK_TOKEN)
all_results = []
for area in settings.AREAS:
all_results += scrape_area(area)
print '{}: Got {} results'.format(time.ctime(), len(all_results))
for result in all_results:
post_listing_to_slack(sc, result)
| [
"def",
"do_scrape",
"(",
")",
":",
"sc",
"=",
"SlackClient",
"(",
"settings",
".",
"SLACK_TOKEN",
")",
"all_results",
"=",
"[",
"]",
"for",
"area",
"in",
"settings",
".",
"AREAS",
":",
"all_results",
"+=",
"scrape_area",
"(",
"area",
")",
"print",
"'{}: ... | runs the craigslist scraper . | train | false |
50,281 | def is_s3_uri(uri):
try:
parse_s3_uri(uri)
return True
except ValueError:
return False
| [
"def",
"is_s3_uri",
"(",
"uri",
")",
":",
"try",
":",
"parse_s3_uri",
"(",
"uri",
")",
"return",
"True",
"except",
"ValueError",
":",
"return",
"False"
] | return true if *uri* can be parsed into an s3 uri . | train | false |
50,282 | def debug_repr(obj):
return DebugReprGenerator().repr(obj)
| [
"def",
"debug_repr",
"(",
"obj",
")",
":",
"return",
"DebugReprGenerator",
"(",
")",
".",
"repr",
"(",
"obj",
")"
] | creates a debug repr of an object as html unicode string . | train | false |
50,284 | def from_file(filepath, delimiter='', blanklines=False):
data = []
try:
with open(filepath, 'r') as f:
for line in f:
if (blanklines and (line.strip('\n\r ') == '')):
continue
data.append(line)
except IOError:
raise IOError('Error opening or reading file: {}'.format(filepath))
return Base64(Join(delimiter, data))
| [
"def",
"from_file",
"(",
"filepath",
",",
"delimiter",
"=",
"''",
",",
"blanklines",
"=",
"False",
")",
":",
"data",
"=",
"[",
"]",
"try",
":",
"with",
"open",
"(",
"filepath",
",",
"'r'",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"if",... | imports userdata from a file . | train | true |
50,285 | def _findNewest():
path = os.path.expanduser((('~/Library/Application Support/Skype/' + getUserName()) + '/main.db'))
with contextlib.closing(sqlite3.connect(path).cursor()) as db:
db.execute('SELECT skypename,fullname,displayname FROM Contacts WHERE skypename IN (SELECT identity FROM Conversations ORDER BY last_activity_timestamp DESC LIMIT 5)')
return _listFriends(db.fetchall(), ': ', True, True)
| [
"def",
"_findNewest",
"(",
")",
":",
"path",
"=",
"os",
".",
"path",
".",
"expanduser",
"(",
"(",
"(",
"'~/Library/Application Support/Skype/'",
"+",
"getUserName",
"(",
")",
")",
"+",
"'/main.db'",
")",
")",
"with",
"contextlib",
".",
"closing",
"(",
"sql... | get newest messages from skype database :return: list of tuples of friends . | train | false |
50,286 | def order_by_name(query, table, language=None, *extra_languages, **kwargs):
name_attribute = kwargs.pop('name', 'name')
if kwargs:
raise ValueError(('Unexpected keyword arguments: %s' % kwargs.keys()))
order_columns = []
if (language is None):
query = query.outerjoin(table.names_local)
order_columns.append(func.lower(getattr(table.names_table, name_attribute)))
else:
extra_languages = ((language,) + extra_languages)
for language in extra_languages:
names_table = aliased(table.names_table)
query = query.outerjoin(names_table)
query = query.filter((names_table.foreign_id == table.id))
query = query.filter((names_table.local_language_id == language.id))
order_columns.append(func.lower(getattr(names_table, name_attribute)))
order_columns.append(table.identifier)
query = query.order_by(coalesce(*order_columns))
return query
| [
"def",
"order_by_name",
"(",
"query",
",",
"table",
",",
"language",
"=",
"None",
",",
"*",
"extra_languages",
",",
"**",
"kwargs",
")",
":",
"name_attribute",
"=",
"kwargs",
".",
"pop",
"(",
"'name'",
",",
"'name'",
")",
"if",
"kwargs",
":",
"raise",
... | order a query by name . | train | false |
50,288 | def GetFileLength(fh):
pos = fh.tell()
fh.seek(0, 2)
length = fh.tell()
fh.seek(pos, 0)
return length
| [
"def",
"GetFileLength",
"(",
"fh",
")",
":",
"pos",
"=",
"fh",
".",
"tell",
"(",
")",
"fh",
".",
"seek",
"(",
"0",
",",
"2",
")",
"length",
"=",
"fh",
".",
"tell",
"(",
")",
"fh",
".",
"seek",
"(",
"pos",
",",
"0",
")",
"return",
"length"
] | returns the length of the file represented by fh . | train | false |
50,289 | def host_to_device(dst, src, size, stream=0):
varargs = []
if stream:
assert isinstance(stream, Stream)
fn = driver.cuMemcpyHtoDAsync
varargs.append(stream.handle)
else:
fn = driver.cuMemcpyHtoD
fn(device_pointer(dst), host_pointer(src), size, *varargs)
| [
"def",
"host_to_device",
"(",
"dst",
",",
"src",
",",
"size",
",",
"stream",
"=",
"0",
")",
":",
"varargs",
"=",
"[",
"]",
"if",
"stream",
":",
"assert",
"isinstance",
"(",
"stream",
",",
"Stream",
")",
"fn",
"=",
"driver",
".",
"cuMemcpyHtoDAsync",
... | note: the underlying data pointer from the host data buffer is used and it should not be changed until the operation which can be asynchronous completes . | train | false |
50,290 | def project_has_valid_admins(project, exclude_user=None):
admin_memberships = project.memberships.filter(is_admin=True, user__is_active=True)
if exclude_user:
admin_memberships = admin_memberships.exclude(user=exclude_user)
return (admin_memberships.count() > 0)
| [
"def",
"project_has_valid_admins",
"(",
"project",
",",
"exclude_user",
"=",
"None",
")",
":",
"admin_memberships",
"=",
"project",
".",
"memberships",
".",
"filter",
"(",
"is_admin",
"=",
"True",
",",
"user__is_active",
"=",
"True",
")",
"if",
"exclude_user",
... | checks if the project has any owner membership with a user different than the specified . | train | false |
50,291 | def cycles(seq):
n = len(seq)
cycled_seq = cycle(seq)
for x in seq:
(yield tuple(islice(cycled_seq, n)))
next(cycled_seq)
| [
"def",
"cycles",
"(",
"seq",
")",
":",
"n",
"=",
"len",
"(",
"seq",
")",
"cycled_seq",
"=",
"cycle",
"(",
"seq",
")",
"for",
"x",
"in",
"seq",
":",
"(",
"yield",
"tuple",
"(",
"islice",
"(",
"cycled_seq",
",",
"n",
")",
")",
")",
"next",
"(",
... | yields cyclic permutations of the given sequence . | train | false |
50,292 | @verbose
def _download_all_example_data(verbose=True):
from . import sample, testing, misc, spm_face, somato, brainstorm, megsim, eegbci, multimodal
sample.data_path()
testing.data_path()
misc.data_path()
spm_face.data_path()
somato.data_path()
multimodal.data_path()
sys.argv += ['--accept-brainstorm-license']
try:
brainstorm.bst_raw.data_path()
brainstorm.bst_auditory.data_path()
brainstorm.bst_phantom_elekta.data_path()
brainstorm.bst_phantom_ctf.data_path()
finally:
sys.argv.pop((-1))
megsim.load_data(condition='visual', data_format='single-trial', data_type='simulation', update_path=True)
megsim.load_data(condition='visual', data_format='raw', data_type='experimental', update_path=True)
megsim.load_data(condition='visual', data_format='evoked', data_type='simulation', update_path=True)
eegbci.load_data(1, [6, 10, 14], update_path=True)
sys.argv += ['--accept-hcpmmp-license']
try:
fetch_hcp_mmp_parcellation()
finally:
sys.argv.pop((-1))
| [
"@",
"verbose",
"def",
"_download_all_example_data",
"(",
"verbose",
"=",
"True",
")",
":",
"from",
".",
"import",
"sample",
",",
"testing",
",",
"misc",
",",
"spm_face",
",",
"somato",
",",
"brainstorm",
",",
"megsim",
",",
"eegbci",
",",
"multimodal",
"s... | helper to download all datasets used in examples and tutorials . | train | false |
50,294 | def get_builtin_gnu_translations(languages=None):
import gettext
return gettext.translation('wtforms', messages_path(), languages)
| [
"def",
"get_builtin_gnu_translations",
"(",
"languages",
"=",
"None",
")",
":",
"import",
"gettext",
"return",
"gettext",
".",
"translation",
"(",
"'wtforms'",
",",
"messages_path",
"(",
")",
",",
"languages",
")"
] | get a gettext . | train | false |
50,295 | @step(((STEP_PREFIX + '([A-Z][a-z0-9_ ]*) with ([a-z]+) "([^"]*)"') + ' is linked to ([A-Z][a-z0-9_ ]*) in the database:'))
def create_m2m_links(step, rel_model_name, rel_key, rel_value, relation_name):
lookup = {rel_key: rel_value}
rel_model = get_model(rel_model_name).objects.get(**lookup)
relation = None
for m2m in rel_model._meta.many_to_many:
if (relation_name in (m2m.name, m2m.verbose_name)):
relation = getattr(rel_model, m2m.name)
break
if (not relation):
try:
relation = getattr(rel_model, relation_name)
except AttributeError:
pass
assert relation, ("%s does not have a many-to-many relation named '%s'" % (rel_model._meta.verbose_name.capitalize(), relation_name))
m2m_model = relation.model
for hash_ in step.hashes:
relation.add(m2m_model.objects.get(**hash_))
| [
"@",
"step",
"(",
"(",
"(",
"STEP_PREFIX",
"+",
"'([A-Z][a-z0-9_ ]*) with ([a-z]+) \"([^\"]*)\"'",
")",
"+",
"' is linked to ([A-Z][a-z0-9_ ]*) in the database:'",
")",
")",
"def",
"create_m2m_links",
"(",
"step",
",",
"rel_model_name",
",",
"rel_key",
",",
"rel_value",
... | and article with name "guidelines" is linked to tags in the database: | name | | coding | | style | . | train | true |
50,296 | def create_dataset(dataset_name, project=None):
bigquery_client = bigquery.Client(project=project)
dataset = bigquery_client.dataset(dataset_name)
dataset.create()
print 'Created dataset {}.'.format(dataset_name)
| [
"def",
"create_dataset",
"(",
"dataset_name",
",",
"project",
"=",
"None",
")",
":",
"bigquery_client",
"=",
"bigquery",
".",
"Client",
"(",
"project",
"=",
"project",
")",
"dataset",
"=",
"bigquery_client",
".",
"dataset",
"(",
"dataset_name",
")",
"dataset",... | create a dataset . | train | false |
50,298 | def SetNamespace(proto, namespace):
if (not namespace):
proto.clear_name_space()
else:
proto.set_name_space(namespace)
| [
"def",
"SetNamespace",
"(",
"proto",
",",
"namespace",
")",
":",
"if",
"(",
"not",
"namespace",
")",
":",
"proto",
".",
"clear_name_space",
"(",
")",
"else",
":",
"proto",
".",
"set_name_space",
"(",
"namespace",
")"
] | sets the namespace for a protocol buffer or clears the field . | train | false |
50,299 | def ireplace(text, old, new, count=None):
pattern = re.compile(re.escape(old), re.IGNORECASE)
if count:
return pattern.sub(new, text, count=count)
else:
return pattern.sub(new, text)
| [
"def",
"ireplace",
"(",
"text",
",",
"old",
",",
"new",
",",
"count",
"=",
"None",
")",
":",
"pattern",
"=",
"re",
".",
"compile",
"(",
"re",
".",
"escape",
"(",
"old",
")",
",",
"re",
".",
"IGNORECASE",
")",
"if",
"count",
":",
"return",
"patter... | a case-insensitive replace() clone . | train | false |
50,300 | def _grid_from_X(X, percentiles=(0.05, 0.95), grid_resolution=100):
if (len(percentiles) != 2):
raise ValueError('percentile must be tuple of len 2')
if (not all(((0.0 <= x <= 1.0) for x in percentiles))):
raise ValueError('percentile values must be in [0, 1]')
axes = []
for col in range(X.shape[1]):
uniques = np.unique(X[:, col])
if (uniques.shape[0] < grid_resolution):
axis = uniques
else:
emp_percentiles = mquantiles(X, prob=percentiles, axis=0)
axis = np.linspace(emp_percentiles[(0, col)], emp_percentiles[(1, col)], num=grid_resolution, endpoint=True)
axes.append(axis)
return (cartesian(axes), axes)
| [
"def",
"_grid_from_X",
"(",
"X",
",",
"percentiles",
"=",
"(",
"0.05",
",",
"0.95",
")",
",",
"grid_resolution",
"=",
"100",
")",
":",
"if",
"(",
"len",
"(",
"percentiles",
")",
"!=",
"2",
")",
":",
"raise",
"ValueError",
"(",
"'percentile must be tuple ... | generate a grid of points based on the percentiles of x . | train | false |
50,301 | def _bytes2int(LSB, MSB):
return int(((256 * int(MSB)) | int(LSB)))
| [
"def",
"_bytes2int",
"(",
"LSB",
",",
"MSB",
")",
":",
"return",
"int",
"(",
"(",
"(",
"256",
"*",
"int",
"(",
"MSB",
")",
")",
"|",
"int",
"(",
"LSB",
")",
")",
")"
] | convert two 8 bit bytes to one integer . | train | false |
50,306 | @pytest.mark.parametrize('value', [[u'foo\\bar'], [u' DCTB foo\\bar\n'], [u'fo\xf6\r\nb\xe4r'], [u'fo\xf6\\r\\nb\xe4r'], [u'fo\xf6\r\n\\r\\nb\xe4r', u'b\xe4r\r\n\\r\\nb\xe4z'], [u'nfo\xf6\nb\xe4r'], [u'nfo\xf6\\nb\xe4r'], [u'fo\xf6\n\\nb\xe4r', u'b\xe4r\n\\nb\xe4z']])
def test_form_multistringformfield(value):
def test_form_factory(nplurals):
class TestForm(Form, ):
value = MultiStringFormField(nplurals=nplurals)
return TestForm
data = {('value_%d' % i): val for (i, val) in enumerate(value)}
form_class = test_form_factory(nplurals=len(value))
form = form_class(data=data)
assert form.is_valid()
assert (form.cleaned_data == {'value': value})
| [
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'value'",
",",
"[",
"[",
"u'foo\\\\bar'",
"]",
",",
"[",
"u' DCTB foo\\\\bar\\n'",
"]",
",",
"[",
"u'fo\\xf6\\r\\nb\\xe4r'",
"]",
",",
"[",
"u'fo\\xf6\\\\r\\\\nb\\xe4r'",
"]",
",",
"[",
"u'fo\\xf6\\r\\n\\\\r... | tests multistringformfields value compression in a form . | train | false |
50,307 | def is_class_instance(obj):
try:
cls = obj.__class__
except AttributeError:
return False
else:
return ((cls != type) and (not issubclass(cls, NOT_CLASS_TYPES)))
| [
"def",
"is_class_instance",
"(",
"obj",
")",
":",
"try",
":",
"cls",
"=",
"obj",
".",
"__class__",
"except",
"AttributeError",
":",
"return",
"False",
"else",
":",
"return",
"(",
"(",
"cls",
"!=",
"type",
")",
"and",
"(",
"not",
"issubclass",
"(",
"cls... | like inspect . | train | false |
50,309 | def insert_into_module(func, module_name, base_name, prefix):
func.__module__ = module_name
module = sys.modules[module_name]
for i in range(1000):
func.__name__ = str((u'%s_%s_%s' % (prefix, base_name, i)))
if (not hasattr(module, func.__name__)):
break
setattr(module, func.__name__, func)
| [
"def",
"insert_into_module",
"(",
"func",
",",
"module_name",
",",
"base_name",
",",
"prefix",
")",
":",
"func",
".",
"__module__",
"=",
"module_name",
"module",
"=",
"sys",
".",
"modules",
"[",
"module_name",
"]",
"for",
"i",
"in",
"range",
"(",
"1000",
... | add a function into a module . | train | false |
50,310 | def list_loadbalancers(call=None):
if (call == 'action'):
raise SaltCloudSystemExit('The avail_images function must be called with -f or --function, or with the --list-loadbalancers option')
ret = {}
conn = get_conn()
datacenter = get_datacenter(conn)
for item in conn.list_loadbalancers(datacenter['id'])['items']:
lb = {'id': item['id']}
lb.update(item['properties'])
ret[lb['name']] = lb
return ret
| [
"def",
"list_loadbalancers",
"(",
"call",
"=",
"None",
")",
":",
"if",
"(",
"call",
"==",
"'action'",
")",
":",
"raise",
"SaltCloudSystemExit",
"(",
"'The avail_images function must be called with -f or --function, or with the --list-loadbalancers option'",
")",
"ret",
"=",... | return a list of the loadbalancers that are on the provider . | train | true |
50,316 | def test_cache_get_nonexistent_data(config_stub, tmpdir):
config_stub.data = {'storage': {'cache-size': 1024}, 'general': {'private-browsing': False}}
disk_cache = cache.DiskCache(str(tmpdir))
preload_cache(disk_cache, 'https://qutebrowser.org')
assert (disk_cache.data(QUrl('http://qutebrowser.org')) is None)
| [
"def",
"test_cache_get_nonexistent_data",
"(",
"config_stub",
",",
"tmpdir",
")",
":",
"config_stub",
".",
"data",
"=",
"{",
"'storage'",
":",
"{",
"'cache-size'",
":",
"1024",
"}",
",",
"'general'",
":",
"{",
"'private-browsing'",
":",
"False",
"}",
"}",
"d... | test querying some data that was never inserted . | train | false |
50,319 | def disaggregate(statistic, data):
new_statistic = {}
for (loc, details) in data.items():
new_statistic[loc] = {}
prev_value = 0
for key in sorted(details.keys()):
new_value = details[key][0]
if (prev_value != new_value):
if (new_value is None):
if prev_value:
rejected_data[loc] = [key, 'None value', statistic, new_value, prev_value]
continue
else:
new_value = 0
if ((new_value < prev_value) and (statistic not in ('Suspected cases', 'Probable cases'))):
suspect_data[loc] = [key, 'Value went down', statistic, new_value, prev_value]
details[key][0] = (new_value - prev_value)
prev_value = new_value
new_statistic[loc][key] = details[key]
return new_statistic
| [
"def",
"disaggregate",
"(",
"statistic",
",",
"data",
")",
":",
"new_statistic",
"=",
"{",
"}",
"for",
"(",
"loc",
",",
"details",
")",
"in",
"data",
".",
"items",
"(",
")",
":",
"new_statistic",
"[",
"loc",
"]",
"=",
"{",
"}",
"prev_value",
"=",
"... | dis-aggregate the running total for each statistic . | train | false |
50,321 | def capture_payment(is_sandbox=False, sanbox_response=None):
controller = frappe.get_doc(u'Razorpay Settings')
for doc in frappe.get_all(u'Integration Request', filters={u'status': u'Authorized', u'integration_request_service': u'Razorpay'}, fields=[u'name', u'data']):
try:
if is_sandbox:
resp = sanbox_response
else:
data = json.loads(doc.data)
settings = controller.get_settings(data)
resp = controller.post_request(u'https://api.razorpay.com/v1/payments/{0}/capture'.format(data.get(u'razorpay_payment_id')), auth=(settings.api_key, settings.api_secret), data={u'amount': data.get(u'amount')})
if (resp.get(u'status') == u'captured'):
frappe.db.set_value(u'Integration Request', doc.name, u'status', u'Completed')
except Exception:
doc = frappe.get_doc(u'Integration Request', doc.name)
doc.status = u'Failed'
doc.error = frappe.get_traceback()
frappe.log_error(doc.error, u'{0} Failed'.format(doc.name))
| [
"def",
"capture_payment",
"(",
"is_sandbox",
"=",
"False",
",",
"sanbox_response",
"=",
"None",
")",
":",
"controller",
"=",
"frappe",
".",
"get_doc",
"(",
"u'Razorpay Settings'",
")",
"for",
"doc",
"in",
"frappe",
".",
"get_all",
"(",
"u'Integration Request'",
... | verifies the purchase as complete by the merchant . | train | false |
50,322 | def parse_hybi00_frames(buf):
start = buf.find('\x00')
tail = 0
frames = []
while (start != (-1)):
end = buf.find('\xff', (start + 1))
if (end == (-1)):
break
else:
frame = buf[(start + 1):end]
frames.append((NORMAL, frame))
tail = (end + 1)
start = buf.find('\x00', (end + 1))
buf = buf[tail:]
return (frames, buf)
| [
"def",
"parse_hybi00_frames",
"(",
"buf",
")",
":",
"start",
"=",
"buf",
".",
"find",
"(",
"'\\x00'",
")",
"tail",
"=",
"0",
"frames",
"=",
"[",
"]",
"while",
"(",
"start",
"!=",
"(",
"-",
"1",
")",
")",
":",
"end",
"=",
"buf",
".",
"find",
"("... | parse hybi-00 frames . | train | false |
50,323 | def generate_patch_base(x, y, base=0.0):
x = x.values
y = y.values
y0 = np.insert(y, 0, base)
y0 = np.append(y0, base)
x0 = np.insert(x, 0, x[0])
x0 = np.append(x0, x0[(-1)])
return (x0, y0)
| [
"def",
"generate_patch_base",
"(",
"x",
",",
"y",
",",
"base",
"=",
"0.0",
")",
":",
"x",
"=",
"x",
".",
"values",
"y",
"=",
"y",
".",
"values",
"y0",
"=",
"np",
".",
"insert",
"(",
"y",
",",
"0",
",",
"base",
")",
"y0",
"=",
"np",
".",
"ap... | adds base to the start and end of y . | train | false |
50,324 | def get_public_ip():
return file_io.read(constants.PUBLIC_IP_LOC).rstrip()
| [
"def",
"get_public_ip",
"(",
")",
":",
"return",
"file_io",
".",
"read",
"(",
"constants",
".",
"PUBLIC_IP_LOC",
")",
".",
"rstrip",
"(",
")"
] | get the public ip of the current machine . | train | false |
50,325 | def usb_devices(attrs=None, where=None):
return _osquery_cmd(table='usb_devices', attrs=attrs, where=where)
| [
"def",
"usb_devices",
"(",
"attrs",
"=",
"None",
",",
"where",
"=",
"None",
")",
":",
"return",
"_osquery_cmd",
"(",
"table",
"=",
"'usb_devices'",
",",
"attrs",
"=",
"attrs",
",",
"where",
"=",
"where",
")"
] | return usb_devices information from osquery cli example: . | train | false |
50,326 | def _whatsnd(data):
hdr = data[:512]
fakefile = StringIO(hdr)
for testfn in sndhdr.tests:
res = testfn(hdr, fakefile)
if (res is not None):
return _sndhdr_MIMEmap.get(res[0])
return None
| [
"def",
"_whatsnd",
"(",
"data",
")",
":",
"hdr",
"=",
"data",
"[",
":",
"512",
"]",
"fakefile",
"=",
"StringIO",
"(",
"hdr",
")",
"for",
"testfn",
"in",
"sndhdr",
".",
"tests",
":",
"res",
"=",
"testfn",
"(",
"hdr",
",",
"fakefile",
")",
"if",
"(... | try to identify a sound file type . | train | true |
50,327 | def attr_call():
return __salt__.grains.items()
| [
"def",
"attr_call",
"(",
")",
":",
"return",
"__salt__",
".",
"grains",
".",
"items",
"(",
")"
] | call grains . | train | false |
50,329 | def survey_getAllQuestionsForTemplate(template_id):
s3db = current.s3db
sectable = s3db.survey_section
q_ltable = s3db.survey_question_list
qsntable = s3db.survey_question
query = (((q_ltable.template_id == template_id) & (q_ltable.section_id == sectable.id)) & (q_ltable.question_id == qsntable.id))
rows = current.db(query).select(qsntable.id, qsntable.code, qsntable.name, qsntable.type, sectable.name, q_ltable.posn, orderby=q_ltable.posn)
questions = []
for row in rows:
question = {}
question_row = row.survey_question
question['qstn_id'] = question_row.id
question['code'] = question_row.code
question['name'] = s3db.survey_qstn_name_represent(question_row.name)
question['type'] = question_row.type
question['posn'] = row.survey_question_list.posn
question['section'] = row.survey_section.name
questions.append(question)
return questions
| [
"def",
"survey_getAllQuestionsForTemplate",
"(",
"template_id",
")",
":",
"s3db",
"=",
"current",
".",
"s3db",
"sectable",
"=",
"s3db",
".",
"survey_section",
"q_ltable",
"=",
"s3db",
".",
"survey_question_list",
"qsntable",
"=",
"s3db",
".",
"survey_question",
"q... | function to return the list of questions for the given template the questions are returned in the order of their position in the template . | train | false |
50,331 | def _get_time(time, tzinfo=None):
if (time is None):
time = datetime.utcnow()
elif isinstance(time, number_types):
time = datetime.utcfromtimestamp(time)
if (time.tzinfo is None):
time = time.replace(tzinfo=UTC)
if isinstance(time, datetime):
if (tzinfo is not None):
time = time.astimezone(tzinfo)
if hasattr(tzinfo, 'normalize'):
time = tzinfo.normalize(time)
time = time.timetz()
elif (tzinfo is not None):
time = time.replace(tzinfo=tzinfo)
return time
| [
"def",
"_get_time",
"(",
"time",
",",
"tzinfo",
"=",
"None",
")",
":",
"if",
"(",
"time",
"is",
"None",
")",
":",
"time",
"=",
"datetime",
".",
"utcnow",
"(",
")",
"elif",
"isinstance",
"(",
"time",
",",
"number_types",
")",
":",
"time",
"=",
"date... | get a timezoned time from a given instant . | train | false |
50,332 | def rmsdiff_2011(im1, im2):
diff = ImageChops.difference(im1, im2)
h = diff.histogram()
sq = ((value * (idx ** 2)) for (idx, value) in enumerate(h))
sum_of_squares = sum(sq)
rms = math.sqrt((sum_of_squares / float((im1.size[0] * im1.size[1]))))
return rms
| [
"def",
"rmsdiff_2011",
"(",
"im1",
",",
"im2",
")",
":",
"diff",
"=",
"ImageChops",
".",
"difference",
"(",
"im1",
",",
"im2",
")",
"h",
"=",
"diff",
".",
"histogram",
"(",
")",
"sq",
"=",
"(",
"(",
"value",
"*",
"(",
"idx",
"**",
"2",
")",
")"... | calculate the root-mean-square difference between two images . | train | false |
50,333 | def vereq(a, b):
if (not (a == b)):
raise TestFailed(('%r == %r' % (a, b)))
| [
"def",
"vereq",
"(",
"a",
",",
"b",
")",
":",
"if",
"(",
"not",
"(",
"a",
"==",
"b",
")",
")",
":",
"raise",
"TestFailed",
"(",
"(",
"'%r == %r'",
"%",
"(",
"a",
",",
"b",
")",
")",
")"
] | raise testfailed if a == b is false . | train | false |
50,335 | def checkHandleAndSynchronize(default=None):
def wrap(f):
def invoke_func(*args, **kwargs):
download = args[0]
with download.dllock:
if (download.handle and download.handle.is_valid()):
return f(*args, **kwargs)
return default
return invoke_func
return wrap
| [
"def",
"checkHandleAndSynchronize",
"(",
"default",
"=",
"None",
")",
":",
"def",
"wrap",
"(",
"f",
")",
":",
"def",
"invoke_func",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"download",
"=",
"args",
"[",
"0",
"]",
"with",
"download",
".",
"dll... | return the libtorrent handle if its available . | train | false |
50,336 | def get_auth_settings():
from mezzanine.conf import settings
try:
auth_settings = (settings.TWITTER_CONSUMER_KEY, settings.TWITTER_CONSUMER_SECRET, settings.TWITTER_ACCESS_TOKEN_KEY, settings.TWITTER_ACCESS_TOKEN_SECRET)
except AttributeError:
return None
else:
return (auth_settings if all(auth_settings) else None)
| [
"def",
"get_auth_settings",
"(",
")",
":",
"from",
"mezzanine",
".",
"conf",
"import",
"settings",
"try",
":",
"auth_settings",
"=",
"(",
"settings",
".",
"TWITTER_CONSUMER_KEY",
",",
"settings",
".",
"TWITTER_CONSUMER_SECRET",
",",
"settings",
".",
"TWITTER_ACCES... | returns all the key/secret settings for twitter access . | train | true |
50,337 | def AllTargets(target_list, target_dicts, build_file):
bftargets = BuildFileTargets(target_list, build_file)
deptargets = DeepDependencyTargets(target_dicts, bftargets)
return (bftargets + deptargets)
| [
"def",
"AllTargets",
"(",
"target_list",
",",
"target_dicts",
",",
"build_file",
")",
":",
"bftargets",
"=",
"BuildFileTargets",
"(",
"target_list",
",",
"build_file",
")",
"deptargets",
"=",
"DeepDependencyTargets",
"(",
"target_dicts",
",",
"bftargets",
")",
"re... | returns all targets for the specified build_file . | train | false |
50,339 | def set_package(fxn):
@functools.wraps(fxn)
def set_package_wrapper(*args, **kwargs):
warnings.warn('The import system now takes care of this automatically.', DeprecationWarning, stacklevel=2)
module = fxn(*args, **kwargs)
if (getattr(module, '__package__', None) is None):
module.__package__ = module.__name__
if (not hasattr(module, '__path__')):
module.__package__ = module.__package__.rpartition('.')[0]
return module
return set_package_wrapper
| [
"def",
"set_package",
"(",
"fxn",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"fxn",
")",
"def",
"set_package_wrapper",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"warnings",
".",
"warn",
"(",
"'The import system now takes care of this automatically.'",... | set __package__ on the returned module . | train | true |
50,340 | def likelihood_ratio_statistic(x, y):
x[(x == 0)] = 1e-05
y[(y == 0)] = 1e-05
y *= (x.sum() / y.sum())
lrs = (2 * (x * np.log((x / y))).sum())
return lrs
| [
"def",
"likelihood_ratio_statistic",
"(",
"x",
",",
"y",
")",
":",
"x",
"[",
"(",
"x",
"==",
"0",
")",
"]",
"=",
"1e-05",
"y",
"[",
"(",
"y",
"==",
"0",
")",
"]",
"=",
"1e-05",
"y",
"*=",
"(",
"x",
".",
"sum",
"(",
")",
"/",
"y",
".",
"su... | calculate likelihood ratio statistic for given distributions . | train | false |
50,341 | def judge(zcontext, in_url, pythagoras_url, out_url):
isock = zcontext.socket(zmq.SUB)
isock.connect(in_url)
for prefix in ('01', '10', '11'):
isock.setsockopt(zmq.SUBSCRIBE, prefix)
psock = zcontext.socket(zmq.REQ)
psock.connect(pythagoras_url)
osock = zcontext.socket(zmq.PUSH)
osock.connect(out_url)
unit = (2 ** (B * 2))
while True:
bits = isock.recv_string()
(n, m) = (int(bits[::2], 2), int(bits[1::2], 2))
psock.send_json((n, m))
sumsquares = psock.recv_json()
osock.send_string(('Y' if (sumsquares < unit) else 'N'))
| [
"def",
"judge",
"(",
"zcontext",
",",
"in_url",
",",
"pythagoras_url",
",",
"out_url",
")",
":",
"isock",
"=",
"zcontext",
".",
"socket",
"(",
"zmq",
".",
"SUB",
")",
"isock",
".",
"connect",
"(",
"in_url",
")",
"for",
"prefix",
"in",
"(",
"'01'",
",... | determine whether each input coordinate is inside the unit circle . | train | false |
50,342 | def MakeComparison(firsts, others):
first_hist = thinkstats2.Hist(firsts.prglngth, label='first')
other_hist = thinkstats2.Hist(others.prglngth, label='other')
width = 0.45
thinkplot.PrePlot(2)
thinkplot.Hist(first_hist, align='right', width=width)
thinkplot.Hist(other_hist, align='left', width=width)
thinkplot.Save(root='first_nsfg_hist', title='Histogram', xlabel='weeks', ylabel='frequency', axis=[27, 46, 0, 2700])
| [
"def",
"MakeComparison",
"(",
"firsts",
",",
"others",
")",
":",
"first_hist",
"=",
"thinkstats2",
".",
"Hist",
"(",
"firsts",
".",
"prglngth",
",",
"label",
"=",
"'first'",
")",
"other_hist",
"=",
"thinkstats2",
".",
"Hist",
"(",
"others",
".",
"prglngth"... | plots histograms of pregnancy length for first babies and others . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.