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 |
|---|---|---|---|---|---|
15,038 | @cli.command()
@click.option('-d', '--directory', default='./', type=click.Path(), required=True)
def examples(directory):
source_dir = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'examples')
try:
shutil.copytree(source_dir, os.path.join(directory, 'examples'))
except OSError as e:
if (e.errno == errno.EEXIST):
print_('Folder examples is exists.')
| [
"@",
"cli",
".",
"command",
"(",
")",
"@",
"click",
".",
"option",
"(",
"'-d'",
",",
"'--directory'",
",",
"default",
"=",
"'./'",
",",
"type",
"=",
"click",
".",
"Path",
"(",
")",
",",
"required",
"=",
"True",
")",
"def",
"examples",
"(",
"directo... | generate example strategies to target folder . | train | false |
15,039 | def htons(integer):
return ntohs(integer)
| [
"def",
"htons",
"(",
"integer",
")",
":",
"return",
"ntohs",
"(",
"integer",
")"
] | convert integer in n from host-byte order to network-byte order . | train | false |
15,041 | def callInThreadPool(fun, *args, **kwargs):
if isInThreadPool():
fun(*args, **kwargs)
else:
reactor.callFromThread(reactor.callInThread, fun, *args, **kwargs)
| [
"def",
"callInThreadPool",
"(",
"fun",
",",
"*",
"args",
",",
"**",
"kwargs",
")",
":",
"if",
"isInThreadPool",
"(",
")",
":",
"fun",
"(",
"*",
"args",
",",
"**",
"kwargs",
")",
"else",
":",
"reactor",
".",
"callFromThread",
"(",
"reactor",
".",
"cal... | calls fun in the reactors thread pool . | train | false |
15,043 | def p_init_declarator_list_2(t):
pass
| [
"def",
"p_init_declarator_list_2",
"(",
"t",
")",
":",
"pass"
] | init_declarator_list : init_declarator_list comma init_declarator . | train | false |
15,045 | def merge_mean_color(graph, src, dst):
graph.node[dst]['total color'] += graph.node[src]['total color']
graph.node[dst]['pixel count'] += graph.node[src]['pixel count']
graph.node[dst]['mean color'] = (graph.node[dst]['total color'] / graph.node[dst]['pixel count'])
| [
"def",
"merge_mean_color",
"(",
"graph",
",",
"src",
",",
"dst",
")",
":",
"graph",
".",
"node",
"[",
"dst",
"]",
"[",
"'total color'",
"]",
"+=",
"graph",
".",
"node",
"[",
"src",
"]",
"[",
"'total color'",
"]",
"graph",
".",
"node",
"[",
"dst",
"... | callback called before merging two nodes of a mean color distance graph . | train | false |
15,047 | def random_organism():
genome = random_genome()
return Organism(genome, test_fitness)
| [
"def",
"random_organism",
"(",
")",
":",
"genome",
"=",
"random_genome",
"(",
")",
"return",
"Organism",
"(",
"genome",
",",
"test_fitness",
")"
] | generate a random organism . | train | false |
15,048 | def basestation():
return s3_rest_controller()
| [
"def",
"basestation",
"(",
")",
":",
"return",
"s3_rest_controller",
"(",
")"
] | restful crud controller for base stations . | train | false |
15,049 | def observe_lr(optimizer_name='main', observation_key='lr'):
return observe_value(observation_key, (lambda trainer: trainer.updater.get_optimizer(optimizer_name).lr))
| [
"def",
"observe_lr",
"(",
"optimizer_name",
"=",
"'main'",
",",
"observation_key",
"=",
"'lr'",
")",
":",
"return",
"observe_value",
"(",
"observation_key",
",",
"(",
"lambda",
"trainer",
":",
"trainer",
".",
"updater",
".",
"get_optimizer",
"(",
"optimizer_name... | returns a trainer extension to record the learning rate . | train | false |
15,050 | def user_confirm(prompt, default=False):
if default:
prompt_default = '[Y/n]'
else:
prompt_default = '[y/N]'
answer = input(('%s %s ' % (prompt, prompt_default)))
if (answer == ''):
return default
else:
return (answer.lower() in ('yes', 'y'))
| [
"def",
"user_confirm",
"(",
"prompt",
",",
"default",
"=",
"False",
")",
":",
"if",
"default",
":",
"prompt_default",
"=",
"'[Y/n]'",
"else",
":",
"prompt_default",
"=",
"'[y/N]'",
"answer",
"=",
"input",
"(",
"(",
"'%s %s '",
"%",
"(",
"prompt",
",",
"p... | yes/no question dialog with user . | train | false |
15,051 | def send_email_for_monthly_fee_payment(email, event_name, date, amount, payment_url):
send_email(to=email, action=MONTHLY_PAYMENT_EMAIL, subject=MAILS[MONTHLY_PAYMENT_EMAIL]['subject'].format(event_name=event_name, date=date), html=MAILS[MONTHLY_PAYMENT_EMAIL]['message'].format(event_name=event_name, date=date, payment_url=payment_url, amount=amount, app_name=get_settings()['app_name']))
| [
"def",
"send_email_for_monthly_fee_payment",
"(",
"email",
",",
"event_name",
",",
"date",
",",
"amount",
",",
"payment_url",
")",
":",
"send_email",
"(",
"to",
"=",
"email",
",",
"action",
"=",
"MONTHLY_PAYMENT_EMAIL",
",",
"subject",
"=",
"MAILS",
"[",
"MONT... | send email every month with invoice to pay service fee . | train | false |
15,052 | def lighten(color, percent):
return adjust(color, 2, percent)
| [
"def",
"lighten",
"(",
"color",
",",
"percent",
")",
":",
"return",
"adjust",
"(",
"color",
",",
"2",
",",
"percent",
")"
] | lighten a color by increasing its lightness by percent . | train | false |
15,053 | def _find_channels(ch_names, ch_type='EOG'):
substrings = (ch_type,)
substrings = [s.upper() for s in substrings]
if (ch_type == 'EOG'):
substrings = ('EOG', 'EYE')
eog_idx = [idx for (idx, ch) in enumerate(ch_names) if any(((substring in ch.upper()) for substring in substrings))]
return eog_idx
| [
"def",
"_find_channels",
"(",
"ch_names",
",",
"ch_type",
"=",
"'EOG'",
")",
":",
"substrings",
"=",
"(",
"ch_type",
",",
")",
"substrings",
"=",
"[",
"s",
".",
"upper",
"(",
")",
"for",
"s",
"in",
"substrings",
"]",
"if",
"(",
"ch_type",
"==",
"'EOG... | find eog channel . | train | false |
15,054 | def test_sobel_v_vertical():
(i, j) = np.mgrid[(-5):6, (-5):6]
image = (j >= 0).astype(float)
result = filters.sobel_v(image)
j[(np.abs(i) == 5)] = 10000
assert np.all((result[(j == 0)] == 1))
assert np.all((result[(np.abs(j) > 1)] == 0))
| [
"def",
"test_sobel_v_vertical",
"(",
")",
":",
"(",
"i",
",",
"j",
")",
"=",
"np",
".",
"mgrid",
"[",
"(",
"-",
"5",
")",
":",
"6",
",",
"(",
"-",
"5",
")",
":",
"6",
"]",
"image",
"=",
"(",
"j",
">=",
"0",
")",
".",
"astype",
"(",
"float... | vertical sobel on an edge should be a vertical line . | train | false |
15,055 | def expand_paths(inputs):
seen = {}
for dirname in inputs:
dirname = normalize_path(dirname)
if (dirname in seen):
continue
seen[dirname] = 1
if (not os.path.isdir(dirname)):
continue
files = os.listdir(dirname)
(yield (dirname, files))
for name in files:
if (not name.endswith('.pth')):
continue
if (name in ('easy-install.pth', 'setuptools.pth')):
continue
f = open(os.path.join(dirname, name))
lines = list(yield_lines(f))
f.close()
for line in lines:
if (not line.startswith('import')):
line = normalize_path(line.rstrip())
if (line not in seen):
seen[line] = 1
if (not os.path.isdir(line)):
continue
(yield (line, os.listdir(line)))
| [
"def",
"expand_paths",
"(",
"inputs",
")",
":",
"seen",
"=",
"{",
"}",
"for",
"dirname",
"in",
"inputs",
":",
"dirname",
"=",
"normalize_path",
"(",
"dirname",
")",
"if",
"(",
"dirname",
"in",
"seen",
")",
":",
"continue",
"seen",
"[",
"dirname",
"]",
... | yield sys . | train | true |
15,056 | def batch_get_value(xs):
if xs:
return get_session().run(xs)
else:
return []
| [
"def",
"batch_get_value",
"(",
"xs",
")",
":",
"if",
"xs",
":",
"return",
"get_session",
"(",
")",
".",
"run",
"(",
"xs",
")",
"else",
":",
"return",
"[",
"]"
] | returns the value of more than one tensor variable . | train | false |
15,057 | @transaction.non_atomic_requests
@ensure_csrf_cookie
@cache_control(no_cache=True, no_store=True, must_revalidate=True)
@require_global_staff
@require_POST
def start_certificate_generation(request, course_id):
course_key = CourseKey.from_string(course_id)
task = lms.djangoapps.instructor_task.api.generate_certificates_for_students(request, course_key)
message = _('Certificate generation task for all students of this course has been started. You can view the status of the generation task in the "Pending Tasks" section.')
response_payload = {'message': message, 'task_id': task.task_id}
return JsonResponse(response_payload)
| [
"@",
"transaction",
".",
"non_atomic_requests",
"@",
"ensure_csrf_cookie",
"@",
"cache_control",
"(",
"no_cache",
"=",
"True",
",",
"no_store",
"=",
"True",
",",
"must_revalidate",
"=",
"True",
")",
"@",
"require_global_staff",
"@",
"require_POST",
"def",
"start_c... | start generating certificates for all students enrolled in given course . | train | false |
15,059 | def get_stories(f, only_supporting=False, max_length=None):
data = parse_stories(f.readlines(), only_supporting=only_supporting)
flatten = (lambda data: reduce((lambda x, y: (x + y)), data))
data = [(flatten(story), q, answer) for (story, q, answer) in data if ((not max_length) or (len(flatten(story)) < max_length))]
return data
| [
"def",
"get_stories",
"(",
"f",
",",
"only_supporting",
"=",
"False",
",",
"max_length",
"=",
"None",
")",
":",
"data",
"=",
"parse_stories",
"(",
"f",
".",
"readlines",
"(",
")",
",",
"only_supporting",
"=",
"only_supporting",
")",
"flatten",
"=",
"(",
... | given a file name . | train | false |
15,060 | def verify_signature(secret, parts):
if (signature(secret, parts[:(-1)]) == parts[(-1)]):
return True
else:
return False
| [
"def",
"verify_signature",
"(",
"secret",
",",
"parts",
")",
":",
"if",
"(",
"signature",
"(",
"secret",
",",
"parts",
"[",
":",
"(",
"-",
"1",
")",
"]",
")",
"==",
"parts",
"[",
"(",
"-",
"1",
")",
"]",
")",
":",
"return",
"True",
"else",
":",... | check the signature in the message . | train | false |
15,062 | def ordinal(value):
try:
value = int(value)
except (TypeError, ValueError):
return value
t = ('th', 'st', 'nd', 'rd', 'th', 'th', 'th', 'th', 'th', 'th')
if ((value % 100) in (11, 12, 13)):
return (u'%d%s' % (value, t[0]))
return (u'%d%s' % (value, t[(value % 10)]))
| [
"def",
"ordinal",
"(",
"value",
")",
":",
"try",
":",
"value",
"=",
"int",
"(",
"value",
")",
"except",
"(",
"TypeError",
",",
"ValueError",
")",
":",
"return",
"value",
"t",
"=",
"(",
"'th'",
",",
"'st'",
",",
"'nd'",
",",
"'rd'",
",",
"'th'",
"... | converts an integer to its ordinal as a string . | train | false |
15,063 | def pnt_func(f):
return double_output(f, [c_void_p, c_int])
| [
"def",
"pnt_func",
"(",
"f",
")",
":",
"return",
"double_output",
"(",
"f",
",",
"[",
"c_void_p",
",",
"c_int",
"]",
")"
] | for accessing point information . | train | false |
15,064 | def cms_documentation(r, default_page, default_url):
row = r.record
if (not row):
name = r.get_vars.get('name', default_page)
table = r.resource.table
query = ((table.name == name) & (table.deleted != True))
row = current.db(query).select(table.id, table.title, table.body, limitby=(0, 1)).first()
if (not row):
if (name != default_page):
r.error(404, current.T('Page not found'), next=URL(args=current.request.args, vars={}))
else:
from s3 import s3_redirect_default
s3_redirect_default(default_url)
from s3 import S3XMLContents
return {'bypass': True, 'output': {'title': row.title, 'contents': S3XMLContents(row.body)}}
| [
"def",
"cms_documentation",
"(",
"r",
",",
"default_page",
",",
"default_url",
")",
":",
"row",
"=",
"r",
".",
"record",
"if",
"(",
"not",
"row",
")",
":",
"name",
"=",
"r",
".",
"get_vars",
".",
"get",
"(",
"'name'",
",",
"default_page",
")",
"table... | render an online documentation page . | train | false |
15,065 | def git_line(*items):
return (' '.join(items) + '\n')
| [
"def",
"git_line",
"(",
"*",
"items",
")",
":",
"return",
"(",
"' '",
".",
"join",
"(",
"items",
")",
"+",
"'\\n'",
")"
] | formats items into a space sepreated line . | train | false |
15,066 | def sanitizeStr(value):
return getUnicode(value).replace('\n', ' ').replace('\r', '')
| [
"def",
"sanitizeStr",
"(",
"value",
")",
":",
"return",
"getUnicode",
"(",
"value",
")",
".",
"replace",
"(",
"'\\n'",
",",
"' '",
")",
".",
"replace",
"(",
"'\\r'",
",",
"''",
")"
] | sanitizes string value in respect to newline and line-feed characters . | train | false |
15,067 | @task
def sharejs(ctx, host=None, port=None, db_url=None, cors_allow_origin=None):
if host:
os.environ['SHAREJS_SERVER_HOST'] = host
if port:
os.environ['SHAREJS_SERVER_PORT'] = port
if db_url:
os.environ['SHAREJS_DB_URL'] = db_url
if cors_allow_origin:
os.environ['SHAREJS_CORS_ALLOW_ORIGIN'] = cors_allow_origin
if settings.SENTRY_DSN:
os.environ['SHAREJS_SENTRY_DSN'] = settings.SENTRY_DSN
share_server = os.path.join(settings.ADDON_PATH, 'wiki', 'shareServer.js')
ctx.run('node {0}'.format(share_server))
| [
"@",
"task",
"def",
"sharejs",
"(",
"ctx",
",",
"host",
"=",
"None",
",",
"port",
"=",
"None",
",",
"db_url",
"=",
"None",
",",
"cors_allow_origin",
"=",
"None",
")",
":",
"if",
"host",
":",
"os",
".",
"environ",
"[",
"'SHAREJS_SERVER_HOST'",
"]",
"=... | start a local sharejs server . | train | false |
15,068 | def assign_role(course_id, user, rolename):
(role, __) = Role.objects.get_or_create(course_id=course_id, name=rolename)
user.roles.add(role)
| [
"def",
"assign_role",
"(",
"course_id",
",",
"user",
",",
"rolename",
")",
":",
"(",
"role",
",",
"__",
")",
"=",
"Role",
".",
"objects",
".",
"get_or_create",
"(",
"course_id",
"=",
"course_id",
",",
"name",
"=",
"rolename",
")",
"user",
".",
"roles",... | assign forum role rolename to user . | train | false |
15,069 | def perform_m_search(local_ip):
search_target = 'urn:schemas-upnp-org:device:InternetGatewayDevice:1'
ssdp_request = ''.join(['M-SEARCH * HTTP/1.1\r\n', 'HOST: 239.255.255.250:1900\r\n', 'MAN: "ssdp:discover"\r\n', 'MX: 2\r\n', 'ST: {0}\r\n'.format(search_target), '\r\n'])
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((local_ip, 10000))
sock.sendto(ssdp_request, ('239.255.255.250', 1900))
if (local_ip == '127.0.0.1'):
sock.settimeout(1)
else:
sock.settimeout(5)
try:
return sock.recv(2048)
except socket.error:
raise UpnpError('No reply from IGD using {} as IP'.format(local_ip))
finally:
sock.close()
| [
"def",
"perform_m_search",
"(",
"local_ip",
")",
":",
"search_target",
"=",
"'urn:schemas-upnp-org:device:InternetGatewayDevice:1'",
"ssdp_request",
"=",
"''",
".",
"join",
"(",
"[",
"'M-SEARCH * HTTP/1.1\\r\\n'",
",",
"'HOST: 239.255.255.250:1900\\r\\n'",
",",
"'MAN: \"ssdp:... | broadcast a udp ssdp m-search packet and return response . | train | false |
15,070 | def set_system_date(newdate, utc_offset=None):
fmts = ['%Y-%m-%d', '%m-%d-%Y', '%m-%d-%y', '%m/%d/%Y', '%m/%d/%y', '%Y/%m/%d']
dt_obj = _try_parse_datetime(newdate, fmts)
if (dt_obj is None):
raise SaltInvocationError('Invalid date format')
return set_system_date_time(years=dt_obj.year, months=dt_obj.month, days=dt_obj.day, utc_offset=utc_offset)
| [
"def",
"set_system_date",
"(",
"newdate",
",",
"utc_offset",
"=",
"None",
")",
":",
"fmts",
"=",
"[",
"'%Y-%m-%d'",
",",
"'%m-%d-%Y'",
",",
"'%m-%d-%y'",
",",
"'%m/%d/%Y'",
",",
"'%m/%d/%y'",
",",
"'%Y/%m/%d'",
"]",
"dt_obj",
"=",
"_try_parse_datetime",
"(",
... | set the windows system date . | train | true |
15,075 | def is_builtin_class_method(obj, attr_name):
classes = [c for c in inspect.getmro(obj) if (attr_name in c.__dict__)]
cls = (classes[0] if classes else object)
if (not hasattr(builtins, safe_getattr(cls, '__name__', ''))):
return False
return (getattr(builtins, safe_getattr(cls, '__name__', '')) is cls)
| [
"def",
"is_builtin_class_method",
"(",
"obj",
",",
"attr_name",
")",
":",
"classes",
"=",
"[",
"c",
"for",
"c",
"in",
"inspect",
".",
"getmro",
"(",
"obj",
")",
"if",
"(",
"attr_name",
"in",
"c",
".",
"__dict__",
")",
"]",
"cls",
"=",
"(",
"classes",... | if attr_name is implemented at builtin class . | train | false |
15,076 | def s_binary(value, name=None):
parsed = value
parsed = parsed.replace(' ', '')
parsed = parsed.replace(' DCTB ', '')
parsed = parsed.replace('\r', '')
parsed = parsed.replace('\n', '')
parsed = parsed.replace(',', '')
parsed = parsed.replace('0x', '')
parsed = parsed.replace('\\x', '')
value = ''
while parsed:
pair = parsed[:2]
parsed = parsed[2:]
value += chr(int(pair, 16))
static = primitives.static(value, name)
blocks.CURRENT.push(static)
| [
"def",
"s_binary",
"(",
"value",
",",
"name",
"=",
"None",
")",
":",
"parsed",
"=",
"value",
"parsed",
"=",
"parsed",
".",
"replace",
"(",
"' '",
",",
"''",
")",
"parsed",
"=",
"parsed",
".",
"replace",
"(",
"' DCTB '",
",",
"''",
")",
"parsed",
"=... | parse a variable format binary string into a static value and push it onto the current block stack . | train | false |
15,079 | @pytest.mark.skipif('not HAS_BEAUTIFUL_SOUP')
def test_no_names():
table_in = ['<table>', '<tr><td>1</td></tr>', '<tr><td>2</td></tr>', '</table>']
dat = Table.read(table_in, format='ascii.html')
assert (dat.colnames == ['col1'])
assert (len(dat) == 2)
dat = Table.read(table_in, format='ascii.html', names=['a'])
assert (dat.colnames == ['a'])
assert (len(dat) == 2)
| [
"@",
"pytest",
".",
"mark",
".",
"skipif",
"(",
"'not HAS_BEAUTIFUL_SOUP'",
")",
"def",
"test_no_names",
"(",
")",
":",
"table_in",
"=",
"[",
"'<table>'",
",",
"'<tr><td>1</td></tr>'",
",",
"'<tr><td>2</td></tr>'",
",",
"'</table>'",
"]",
"dat",
"=",
"Table",
... | test reading a table witn no column header . | train | false |
15,080 | def get_path_style(path, fill=True):
style = {}
style['alpha'] = path.get_alpha()
if (style['alpha'] is None):
style['alpha'] = 1
style['edgecolor'] = color_to_hex(path.get_edgecolor())
if fill:
style['facecolor'] = color_to_hex(path.get_facecolor())
else:
style['facecolor'] = 'none'
style['edgewidth'] = path.get_linewidth()
style['dasharray'] = get_dasharray(path)
style['zorder'] = path.get_zorder()
return style
| [
"def",
"get_path_style",
"(",
"path",
",",
"fill",
"=",
"True",
")",
":",
"style",
"=",
"{",
"}",
"style",
"[",
"'alpha'",
"]",
"=",
"path",
".",
"get_alpha",
"(",
")",
"if",
"(",
"style",
"[",
"'alpha'",
"]",
"is",
"None",
")",
":",
"style",
"["... | get the style dictionary for matplotlib path objects . | train | true |
15,081 | def dllFromDll(dllid):
if (dllid == None):
return None
elif (type('') == type(dllid)):
return win32ui.LoadLibrary(dllid)
else:
try:
dllid.GetFileName()
except AttributeError:
raise TypeError('DLL parameter must be None, a filename or a dll object')
return dllid
| [
"def",
"dllFromDll",
"(",
"dllid",
")",
":",
"if",
"(",
"dllid",
"==",
"None",
")",
":",
"return",
"None",
"elif",
"(",
"type",
"(",
"''",
")",
"==",
"type",
"(",
"dllid",
")",
")",
":",
"return",
"win32ui",
".",
"LoadLibrary",
"(",
"dllid",
")",
... | given a dll . | train | false |
15,082 | def is_available_extension(name, user=None, host=None, port=None, maintenance_db=None, password=None, runas=None):
exts = available_extensions(user=user, host=host, port=port, maintenance_db=maintenance_db, password=password, runas=runas)
if (name.lower() in [a.lower() for a in exts]):
return True
return False
| [
"def",
"is_available_extension",
"(",
"name",
",",
"user",
"=",
"None",
",",
"host",
"=",
"None",
",",
"port",
"=",
"None",
",",
"maintenance_db",
"=",
"None",
",",
"password",
"=",
"None",
",",
"runas",
"=",
"None",
")",
":",
"exts",
"=",
"available_e... | test if a specific extension is available cli example: . | train | true |
15,084 | def list_tables(dataset_name, project=None):
bigquery_client = bigquery.Client(project=project)
dataset = bigquery_client.dataset(dataset_name)
if (not dataset.exists()):
print 'Dataset {} does not exist.'.format(dataset_name)
return
for table in dataset.list_tables():
print table.name
| [
"def",
"list_tables",
"(",
"dataset_name",
",",
"project",
"=",
"None",
")",
":",
"bigquery_client",
"=",
"bigquery",
".",
"Client",
"(",
"project",
"=",
"project",
")",
"dataset",
"=",
"bigquery_client",
".",
"dataset",
"(",
"dataset_name",
")",
"if",
"(",
... | lists all of the tables in a given dataset . | train | false |
15,086 | def receive_message(sock, operation, request_id, max_message_size=MAX_MESSAGE_SIZE):
header = _receive_data_on_socket(sock, 16)
length = _UNPACK_INT(header[:4])[0]
actual_op = _UNPACK_INT(header[12:])[0]
if (operation != actual_op):
raise ProtocolError(('Got opcode %r but expected %r' % (actual_op, operation)))
if (request_id is not None):
response_id = _UNPACK_INT(header[8:12])[0]
if (request_id != response_id):
raise ProtocolError(('Got response id %r but expected %r' % (response_id, request_id)))
if (length <= 16):
raise ProtocolError(('Message length (%r) not longer than standard message header size (16)' % (length,)))
if (length > max_message_size):
raise ProtocolError(('Message length (%r) is larger than server max message size (%r)' % (length, max_message_size)))
return _receive_data_on_socket(sock, (length - 16))
| [
"def",
"receive_message",
"(",
"sock",
",",
"operation",
",",
"request_id",
",",
"max_message_size",
"=",
"MAX_MESSAGE_SIZE",
")",
":",
"header",
"=",
"_receive_data_on_socket",
"(",
"sock",
",",
"16",
")",
"length",
"=",
"_UNPACK_INT",
"(",
"header",
"[",
":"... | run a label request on an image received from twilio . | train | true |
15,088 | def compare_forwards(f1, f2):
assert_allclose(f1['sol']['data'], f2['sol']['data'])
assert_equal(f1['sol']['ncol'], f2['sol']['ncol'])
assert_allclose(f1['source_nn'], f2['source_nn'])
if (f1['sol_grad'] is not None):
assert_true((f2['sol_grad'] is not None))
assert_allclose(f1['sol_grad']['data'], f2['sol_grad']['data'])
assert_equal(f1['sol_grad']['ncol'], f2['sol_grad']['ncol'])
else:
assert_true((f2['sol_grad'] is None))
assert_equal(f1['source_ori'], f2['source_ori'])
assert_equal(f1['surf_ori'], f2['surf_ori'])
| [
"def",
"compare_forwards",
"(",
"f1",
",",
"f2",
")",
":",
"assert_allclose",
"(",
"f1",
"[",
"'sol'",
"]",
"[",
"'data'",
"]",
",",
"f2",
"[",
"'sol'",
"]",
"[",
"'data'",
"]",
")",
"assert_equal",
"(",
"f1",
"[",
"'sol'",
"]",
"[",
"'ncol'",
"]",... | helper to compare two potentially converted forward solutions . | train | false |
15,089 | def compute_P_from_fundamental(F):
e = compute_epipole(F.T)
Te = skew(e)
return vstack((dot(Te, F.T).T, e)).T
| [
"def",
"compute_P_from_fundamental",
"(",
"F",
")",
":",
"e",
"=",
"compute_epipole",
"(",
"F",
".",
"T",
")",
"Te",
"=",
"skew",
"(",
"e",
")",
"return",
"vstack",
"(",
"(",
"dot",
"(",
"Te",
",",
"F",
".",
"T",
")",
".",
"T",
",",
"e",
")",
... | computes the second camera matrix from a fundamental matrix . | train | false |
15,090 | def autoTrack(clip, pattern, tt=None, fps=None, radius=20, xy0=None):
if (not autotracking_possible):
raise IOError('Sorry, autotrack requires OpenCV for the moment. Install OpenCV (aka cv2) to use it.')
if (not xy0):
xy0 = findAround(clip.get_frame(tt[0]), pattern)
if (tt is None):
tt = np.arange(0, clip.duration, (1.0 / fps))
xys = [xy0]
for t in tt[1:]:
xys.append(findAround(clip.get_frame(t), pattern, xy=xys[(-1)], r=radius))
(xx, yy) = zip(*xys)
return Trajectory(tt, xx, yy)
| [
"def",
"autoTrack",
"(",
"clip",
",",
"pattern",
",",
"tt",
"=",
"None",
",",
"fps",
"=",
"None",
",",
"radius",
"=",
"20",
",",
"xy0",
"=",
"None",
")",
":",
"if",
"(",
"not",
"autotracking_possible",
")",
":",
"raise",
"IOError",
"(",
"'Sorry, auto... | tracks a given pattern in a video clip . | train | false |
15,091 | @image_comparison(baseline_images=[u'bbox_inches_tight_raster'], remove_text=True, savefig_kwarg={u'bbox_inches': u'tight'})
def test_bbox_inches_tight_raster():
fig = plt.figure()
ax = fig.add_subplot(111)
ax.plot([1.0, 2.0], rasterized=True)
| [
"@",
"image_comparison",
"(",
"baseline_images",
"=",
"[",
"u'bbox_inches_tight_raster'",
"]",
",",
"remove_text",
"=",
"True",
",",
"savefig_kwarg",
"=",
"{",
"u'bbox_inches'",
":",
"u'tight'",
"}",
")",
"def",
"test_bbox_inches_tight_raster",
"(",
")",
":",
"fig... | test rasterization with tight_layout . | train | false |
15,092 | @hook.command()
@hook.command('tv_prev')
def tv_last(text, bot=None):
api_key = bot.config.get('api_keys', {}).get('tvdb', None)
if (api_key is None):
return 'error: no api key set'
episodes = get_episodes_for_series(text, api_key)
if episodes['error']:
return episodes['error']
series_name = episodes['name']
ended = episodes['ended']
episodes = episodes['episodes']
prev_ep = None
today = datetime.date.today()
for episode in reversed(episodes):
ep_info = get_episode_info(episode)
if (ep_info is None):
continue
(first_aired, air_date, episode_desc) = ep_info
if (air_date < today):
prev_ep = '{} ({})'.format(first_aired, episode_desc)
break
if (not prev_ep):
return 'There are no previously aired episodes for {}.'.format(series_name)
if ended:
return '{} ended. The last episode aired {}.'.format(series_name, prev_ep)
return 'The last episode of {} aired {}.'.format(series_name, prev_ep)
| [
"@",
"hook",
".",
"command",
"(",
")",
"@",
"hook",
".",
"command",
"(",
"'tv_prev'",
")",
"def",
"tv_last",
"(",
"text",
",",
"bot",
"=",
"None",
")",
":",
"api_key",
"=",
"bot",
".",
"config",
".",
"get",
"(",
"'api_keys'",
",",
"{",
"}",
")",
... | tv_last <series> -- gets the most recently aired episode of <series> . | train | false |
15,093 | def iscode(object):
return isinstance(object, types.CodeType)
| [
"def",
"iscode",
"(",
"object",
")",
":",
"return",
"isinstance",
"(",
"object",
",",
"types",
".",
"CodeType",
")"
] | return true if the object is a code object . | train | false |
15,094 | def test_url_incorrect_case_file_index(script, data):
result = script.pip('install', '--index-url', data.find_links3, 'dinner', expect_stderr=True)
egg_folder = ((script.site_packages / 'Dinner-1.0-py%s.egg-info') % pyversion)
assert (egg_folder not in result.files_created), str(result)
egg_folder = ((script.site_packages / 'Dinner-2.0-py%s.egg-info') % pyversion)
assert (egg_folder in result.files_created), str(result)
| [
"def",
"test_url_incorrect_case_file_index",
"(",
"script",
",",
"data",
")",
":",
"result",
"=",
"script",
".",
"pip",
"(",
"'install'",
",",
"'--index-url'",
",",
"data",
".",
"find_links3",
",",
"'dinner'",
",",
"expect_stderr",
"=",
"True",
")",
"egg_folde... | same as test_url_req_case_mismatch_file_index . | train | false |
15,095 | def query_helper(query, add=None, remove=None):
add = string_to_dict(add)
remove = string_to_list(remove)
params = query.copy()
return get_query_string(params, add, remove)
| [
"def",
"query_helper",
"(",
"query",
",",
"add",
"=",
"None",
",",
"remove",
"=",
"None",
")",
":",
"add",
"=",
"string_to_dict",
"(",
"add",
")",
"remove",
"=",
"string_to_list",
"(",
"remove",
")",
"params",
"=",
"query",
".",
"copy",
"(",
")",
"re... | helper function for use within views . | train | false |
15,096 | def do_collectstatic():
try:
build.make_collectstatic()
return True
except (OSError, SystemError) as ex:
LOG.error(("Failed to collect the static files. Please fix any problem and run `%s --collectstatic'\n%s" % (PROG_NAME, ex)))
return False
| [
"def",
"do_collectstatic",
"(",
")",
":",
"try",
":",
"build",
".",
"make_collectstatic",
"(",
")",
"return",
"True",
"except",
"(",
"OSError",
",",
"SystemError",
")",
"as",
"ex",
":",
"LOG",
".",
"error",
"(",
"(",
"\"Failed to collect the static files. Plea... | collects the static files . | train | false |
15,099 | def get_archive_content(filename):
archive = get_archive(filename)
stack.append((filename, archive))
output = []
get_content(archive, recursive=True, brief=True, output=output)
do_cleanup()
return output
| [
"def",
"get_archive_content",
"(",
"filename",
")",
":",
"archive",
"=",
"get_archive",
"(",
"filename",
")",
"stack",
".",
"append",
"(",
"(",
"filename",
",",
"archive",
")",
")",
"output",
"=",
"[",
"]",
"get_content",
"(",
"archive",
",",
"recursive",
... | get a list of the content of archive filename . | train | false |
15,101 | @public
def factor_list(f, *gens, **args):
return _generic_factor_list(f, gens, args, method='factor')
| [
"@",
"public",
"def",
"factor_list",
"(",
"f",
",",
"*",
"gens",
",",
"**",
"args",
")",
":",
"return",
"_generic_factor_list",
"(",
"f",
",",
"gens",
",",
"args",
",",
"method",
"=",
"'factor'",
")"
] | compute a list of irreducible factors of f . | train | false |
15,102 | def find_cached_job(jid):
serial = salt.payload.Serial(__opts__)
proc_dir = os.path.join(__opts__['cachedir'], 'minion_jobs')
job_dir = os.path.join(proc_dir, str(jid))
if (not os.path.isdir(job_dir)):
if (not __opts__.get('cache_jobs')):
return 'Local jobs cache directory not found; you may need to enable cache_jobs on this minion'
else:
return 'Local jobs cache directory {0} not found'.format(job_dir)
path = os.path.join(job_dir, 'return.p')
with salt.utils.fopen(path, 'rb') as fp_:
buf = fp_.read()
fp_.close()
if buf:
try:
data = serial.loads(buf)
except NameError:
return
else:
return
if (not isinstance(data, dict)):
return
return data
| [
"def",
"find_cached_job",
"(",
"jid",
")",
":",
"serial",
"=",
"salt",
".",
"payload",
".",
"Serial",
"(",
"__opts__",
")",
"proc_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"__opts__",
"[",
"'cachedir'",
"]",
",",
"'minion_jobs'",
")",
"job_dir",
... | return the data for a specific cached job id . | train | true |
15,105 | def lod_to_dod(_list, indexkey):
results = {}
for item in _list:
results[item[indexkey]] = item
return results
| [
"def",
"lod_to_dod",
"(",
"_list",
",",
"indexkey",
")",
":",
"results",
"=",
"{",
"}",
"for",
"item",
"in",
"_list",
":",
"results",
"[",
"item",
"[",
"indexkey",
"]",
"]",
"=",
"item",
"return",
"results"
] | things like get_distros() returns a list of a dictionaries convert this to a dict of dicts keyed off of an arbitrary field ex: [ { "a" : 2 } . | train | false |
15,106 | def replace_leaf(arg, leaves, new_leaves, op, neg):
for (idx, x) in enumerate(leaves):
if (x[0] == arg):
x[1][0] ^= neg
x[1][1] = op(arg)
leaves.pop(idx)
new_leaves.append(x)
return True
return False
| [
"def",
"replace_leaf",
"(",
"arg",
",",
"leaves",
",",
"new_leaves",
",",
"op",
",",
"neg",
")",
":",
"for",
"(",
"idx",
",",
"x",
")",
"in",
"enumerate",
"(",
"leaves",
")",
":",
"if",
"(",
"x",
"[",
"0",
"]",
"==",
"arg",
")",
":",
"x",
"["... | attempt to replace a leaf of a multiplication tree . | train | false |
15,107 | def get_event_source_mapping_ids(EventSourceArn, FunctionName, region=None, key=None, keyid=None, profile=None):
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
try:
mappings = []
for maps in salt.utils.boto3.paged_call(conn.list_event_source_mappings, EventSourceArn=EventSourceArn, FunctionName=FunctionName):
mappings.extend([mapping['UUID'] for mapping in maps['EventSourceMappings']])
return mappings
except ClientError as e:
return {'error': salt.utils.boto3.get_error(e)}
| [
"def",
"get_event_source_mapping_ids",
"(",
"EventSourceArn",
",",
"FunctionName",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_get_conn",
"(",
"region",
"=",
"region"... | given an event source and function name . | train | false |
15,109 | @validation_task
def validate_file(file_id, hash_, is_webextension=False, **kw):
file_ = File.objects.get(pk=file_id)
try:
return file_.validation.validation
except FileValidation.DoesNotExist:
listed = (file_.version.channel == amo.RELEASE_CHANNEL_LISTED)
if is_webextension:
return run_addons_linter(file_.current_file_path, listed=listed)
return run_validator(file_.current_file_path, listed=listed)
| [
"@",
"validation_task",
"def",
"validate_file",
"(",
"file_id",
",",
"hash_",
",",
"is_webextension",
"=",
"False",
",",
"**",
"kw",
")",
":",
"file_",
"=",
"File",
".",
"objects",
".",
"get",
"(",
"pk",
"=",
"file_id",
")",
"try",
":",
"return",
"file... | validate if requirements_all . | train | false |
15,110 | def test_getattr_exceptions():
class AttributeTest(object, ):
def __getattr__(self, name):
raise AttributeError('catch me')
x = AttributeTest()
try:
y = x.throws
except AttributeError as ex:
AreEqual(ex.args, ('catch me',))
else:
Fail('should have thrown')
| [
"def",
"test_getattr_exceptions",
"(",
")",
":",
"class",
"AttributeTest",
"(",
"object",
",",
")",
":",
"def",
"__getattr__",
"(",
"self",
",",
"name",
")",
":",
"raise",
"AttributeError",
"(",
"'catch me'",
")",
"x",
"=",
"AttributeTest",
"(",
")",
"try"... | verify the original exception propagates out . | train | false |
15,112 | def readmission(aFileName):
print ('\nReading mission from file: %s' % aFileName)
cmds = vehicle.commands
missionlist = []
with open(aFileName) as f:
for (i, line) in enumerate(f):
if (i == 0):
if (not line.startswith('QGC WPL 110')):
raise Exception('File is not supported WP version')
else:
linearray = line.split(' DCTB ')
ln_index = int(linearray[0])
ln_currentwp = int(linearray[1])
ln_frame = int(linearray[2])
ln_command = int(linearray[3])
ln_param1 = float(linearray[4])
ln_param2 = float(linearray[5])
ln_param3 = float(linearray[6])
ln_param4 = float(linearray[7])
ln_param5 = float(linearray[8])
ln_param6 = float(linearray[9])
ln_param7 = float(linearray[10])
ln_autocontinue = int(linearray[11].strip())
cmd = Command(0, 0, 0, ln_frame, ln_command, ln_currentwp, ln_autocontinue, ln_param1, ln_param2, ln_param3, ln_param4, ln_param5, ln_param6, ln_param7)
missionlist.append(cmd)
return missionlist
| [
"def",
"readmission",
"(",
"aFileName",
")",
":",
"print",
"(",
"'\\nReading mission from file: %s'",
"%",
"aFileName",
")",
"cmds",
"=",
"vehicle",
".",
"commands",
"missionlist",
"=",
"[",
"]",
"with",
"open",
"(",
"aFileName",
")",
"as",
"f",
":",
"for",
... | load a mission from a file into a list . | train | true |
15,113 | def test_softmax_generality():
nvis = 1
num_classes = 2
model = MLP(layers=[Softmax(num_classes, 's', irange=0.1)], nvis=nvis)
Z = T.matrix()
Y_hat = T.nnet.softmax(Z)
Y = T.matrix()
model.layers[(-1)].cost(Y=Y, Y_hat=Y_hat)
| [
"def",
"test_softmax_generality",
"(",
")",
":",
"nvis",
"=",
"1",
"num_classes",
"=",
"2",
"model",
"=",
"MLP",
"(",
"layers",
"=",
"[",
"Softmax",
"(",
"num_classes",
",",
"'s'",
",",
"irange",
"=",
"0.1",
")",
"]",
",",
"nvis",
"=",
"nvis",
")",
... | tests that the softmax layer can score outputs it did not create . | train | false |
15,114 | @csrf_exempt
def spell_check(request):
try:
if (not enchant):
raise RuntimeError('install pyenchant for spellchecker functionality')
raw = force_text(request.body)
input = json.loads(raw)
id = input['id']
method = input['method']
params = input['params']
lang = params[0]
arg = params[1]
if (not enchant.dict_exists(str(lang))):
raise RuntimeError('dictionary not found for language {!r}'.format(lang))
checker = enchant.Dict(str(lang))
if (method == 'checkWords'):
result = [word for word in arg if (word and (not checker.check(word)))]
elif (method == 'getSuggestions'):
result = checker.suggest(arg)
else:
raise RuntimeError('Unknown spellcheck method: {!r}'.format(method))
output = {'id': id, 'result': result, 'error': None}
except Exception:
logging.exception('Error running spellchecker')
return HttpResponse(_('Error running spellchecker'))
return HttpResponse(json.dumps(output), content_type='application/json')
| [
"@",
"csrf_exempt",
"def",
"spell_check",
"(",
"request",
")",
":",
"try",
":",
"if",
"(",
"not",
"enchant",
")",
":",
"raise",
"RuntimeError",
"(",
"'install pyenchant for spellchecker functionality'",
")",
"raw",
"=",
"force_text",
"(",
"request",
".",
"body",... | returns a httpresponse that implements the tinymce spellchecker protocol . | train | true |
15,117 | def exit_standby(name, instance_ids, should_decrement_desired_capacity=False, region=None, key=None, keyid=None, profile=None):
conn = _get_conn_autoscaling_boto3(region=region, key=key, keyid=keyid, profile=profile)
try:
response = conn.exit_standby(InstanceIds=instance_ids, AutoScalingGroupName=name)
except ClientError as e:
err = salt.utils.boto3.get_error(e)
if (e.response.get('Error', {}).get('Code') == 'ResourceNotFoundException'):
return {'exists': False}
return {'error': err}
return all(((activity['StatusCode'] != 'Failed') for activity in response['Activities']))
| [
"def",
"exit_standby",
"(",
"name",
",",
"instance_ids",
",",
"should_decrement_desired_capacity",
"=",
"False",
",",
"region",
"=",
"None",
",",
"key",
"=",
"None",
",",
"keyid",
"=",
"None",
",",
"profile",
"=",
"None",
")",
":",
"conn",
"=",
"_get_conn_... | exit desired instances from standby mode . | train | true |
15,119 | def get_absolute_url(path):
if is_absolute_url(path):
return path
site = sites.get_current()
return build_url(path, scheme=site.scheme, domain=site.domain)
| [
"def",
"get_absolute_url",
"(",
"path",
")",
":",
"if",
"is_absolute_url",
"(",
"path",
")",
":",
"return",
"path",
"site",
"=",
"sites",
".",
"get_current",
"(",
")",
"return",
"build_url",
"(",
"path",
",",
"scheme",
"=",
"site",
".",
"scheme",
",",
... | generate an absolute url for a resource on the test server . | train | false |
15,120 | def _default_course_mode(course_id):
course_modes = CourseMode.modes_for_course(CourseKey.from_string(course_id))
available_modes = [m.slug for m in course_modes]
if (CourseMode.DEFAULT_MODE_SLUG in available_modes):
return CourseMode.DEFAULT_MODE_SLUG
elif ('audit' in available_modes):
return 'audit'
elif ('honor' in available_modes):
return 'honor'
return CourseMode.DEFAULT_MODE_SLUG
| [
"def",
"_default_course_mode",
"(",
"course_id",
")",
":",
"course_modes",
"=",
"CourseMode",
".",
"modes_for_course",
"(",
"CourseKey",
".",
"from_string",
"(",
"course_id",
")",
")",
"available_modes",
"=",
"[",
"m",
".",
"slug",
"for",
"m",
"in",
"course_mo... | return the default enrollment for a course . | train | false |
15,121 | def get_parsed_option(command_opts, opt_key, default=None):
command_opt_value = getattr(command_opts, opt_key, default)
if command_opt_value:
command_opt_value = listfy(command_opt_value)
return command_opt_value
| [
"def",
"get_parsed_option",
"(",
"command_opts",
",",
"opt_key",
",",
"default",
"=",
"None",
")",
":",
"command_opt_value",
"=",
"getattr",
"(",
"command_opts",
",",
"opt_key",
",",
"default",
")",
"if",
"command_opt_value",
":",
"command_opt_value",
"=",
"list... | extract user command option and parse it . | train | false |
15,122 | def on_agent(path, context):
if (path == ''):
path = '/'
(folder, search_path) = get_folder_and_search_path(path, '/')
folders = context.listFiles(folder)
return [s.replace(' ', '\\ ') for s in get_suggestions(folder, search_path, map((lambda f: str(f)), folders), '/', True)]
| [
"def",
"on_agent",
"(",
"path",
",",
"context",
")",
":",
"if",
"(",
"path",
"==",
"''",
")",
":",
"path",
"=",
"'/'",
"(",
"folder",
",",
"search_path",
")",
"=",
"get_folder_and_search_path",
"(",
"path",
",",
"'/'",
")",
"folders",
"=",
"context",
... | provides path completion . | train | false |
15,123 | def compute_features(net, im):
if config.FLAG_CPU_MODE:
net.blobs['data'].reshape(*im.shape)
net.blobs['data'].data[...] = im
net.forward()
fc7 = net.blobs['fc7'].data
else:
fc7 = numpy.array(lasagne.layers.get_output(net['fc7'], im, deterministic=True).eval())
return fc7
| [
"def",
"compute_features",
"(",
"net",
",",
"im",
")",
":",
"if",
"config",
".",
"FLAG_CPU_MODE",
":",
"net",
".",
"blobs",
"[",
"'data'",
"]",
".",
"reshape",
"(",
"*",
"im",
".",
"shape",
")",
"net",
".",
"blobs",
"[",
"'data'",
"]",
".",
"data",... | compute fc7 features for im . | train | false |
15,124 | def line_graph(G, create_using=None):
if G.is_directed():
L = _lg_directed(G, create_using=create_using)
else:
L = _lg_undirected(G, selfloops=False, create_using=create_using)
return L
| [
"def",
"line_graph",
"(",
"G",
",",
"create_using",
"=",
"None",
")",
":",
"if",
"G",
".",
"is_directed",
"(",
")",
":",
"L",
"=",
"_lg_directed",
"(",
"G",
",",
"create_using",
"=",
"create_using",
")",
"else",
":",
"L",
"=",
"_lg_undirected",
"(",
... | returns the line graph of the graph or digraph g . | train | false |
15,125 | def _write_file_prefix(f, interpreter):
if interpreter:
shebang = (('#!' + interpreter.encode(shebang_encoding)) + '\n')
f.write(shebang)
| [
"def",
"_write_file_prefix",
"(",
"f",
",",
"interpreter",
")",
":",
"if",
"interpreter",
":",
"shebang",
"=",
"(",
"(",
"'#!'",
"+",
"interpreter",
".",
"encode",
"(",
"shebang_encoding",
")",
")",
"+",
"'\\n'",
")",
"f",
".",
"write",
"(",
"shebang",
... | write a shebang line . | train | false |
15,126 | @csrf.exempt
@api_experimental.route('/dags/<string:dag_id>/dag_runs', methods=['POST'])
@requires_authentication
def trigger_dag(dag_id):
data = request.get_json(force=True)
run_id = None
if ('run_id' in data):
run_id = data['run_id']
conf = None
if ('conf' in data):
conf = data['conf']
execution_date = None
if ('execution_date' in data):
execution_date = data['execution_date']
try:
execution_date = datetime.strptime(execution_date, '%Y-%m-%dT%H:%M:%S')
except ValueError:
error_message = 'Given execution date, {}, could not be identified as a date. Example date format: 2015-11-16T14:34:15'.format(execution_date)
_log.info(error_message)
response = jsonify({'error': error_message})
response.status_code = 400
return response
try:
dr = trigger.trigger_dag(dag_id, run_id, conf, execution_date)
except AirflowException as err:
_log.error(err)
response = jsonify(error='{}'.format(err))
response.status_code = 404
return response
if getattr(g, 'user', None):
_log.info('User {} created {}'.format(g.user, dr))
response = jsonify(message='Created {}'.format(dr))
return response
| [
"@",
"csrf",
".",
"exempt",
"@",
"api_experimental",
".",
"route",
"(",
"'/dags/<string:dag_id>/dag_runs'",
",",
"methods",
"=",
"[",
"'POST'",
"]",
")",
"@",
"requires_authentication",
"def",
"trigger_dag",
"(",
"dag_id",
")",
":",
"data",
"=",
"request",
"."... | creates a dag run for the specified dag . | train | false |
15,127 | def getevents(clsid):
clsid = str(pywintypes.IID(clsid))
klass = gencache.GetClassForCLSID(clsid)
try:
return klass.default_source
except AttributeError:
try:
return gencache.GetClassForCLSID(klass.coclass_clsid).default_source
except AttributeError:
return None
| [
"def",
"getevents",
"(",
"clsid",
")",
":",
"clsid",
"=",
"str",
"(",
"pywintypes",
".",
"IID",
"(",
"clsid",
")",
")",
"klass",
"=",
"gencache",
".",
"GetClassForCLSID",
"(",
"clsid",
")",
"try",
":",
"return",
"klass",
".",
"default_source",
"except",
... | determine the default outgoing interface for a class . | train | false |
15,128 | @intercept_errors(UserAPIInternalError, ignore_errors=[UserAPIRequestError])
def get_user_preference(requesting_user, preference_key, username=None):
existing_user = _get_authorized_user(requesting_user, username, allow_staff=True)
return UserPreference.get_value(existing_user, preference_key)
| [
"@",
"intercept_errors",
"(",
"UserAPIInternalError",
",",
"ignore_errors",
"=",
"[",
"UserAPIRequestError",
"]",
")",
"def",
"get_user_preference",
"(",
"requesting_user",
",",
"preference_key",
",",
"username",
"=",
"None",
")",
":",
"existing_user",
"=",
"_get_au... | returns the value of the user preference with the specified key . | train | false |
15,129 | def map_process(path, wp, fen, used_flightmodes, options):
from mavflightview import mavflightview_show
mavflightview_show(path, wp, fen, used_flightmodes, options)
| [
"def",
"map_process",
"(",
"path",
",",
"wp",
",",
"fen",
",",
"used_flightmodes",
",",
"options",
")",
":",
"from",
"mavflightview",
"import",
"mavflightview_show",
"mavflightview_show",
"(",
"path",
",",
"wp",
",",
"fen",
",",
"used_flightmodes",
",",
"optio... | process for displaying a graph . | train | false |
15,131 | def add_user_to_cohort(cohort, username_or_email):
user = get_user_by_username_or_email(username_or_email)
membership = CohortMembership(course_user_group=cohort, user=user)
membership.save()
tracker.emit('edx.cohort.user_add_requested', {'user_id': user.id, 'cohort_id': cohort.id, 'cohort_name': cohort.name, 'previous_cohort_id': membership.previous_cohort_id, 'previous_cohort_name': membership.previous_cohort_name})
return (user, membership.previous_cohort_name)
| [
"def",
"add_user_to_cohort",
"(",
"cohort",
",",
"username_or_email",
")",
":",
"user",
"=",
"get_user_by_username_or_email",
"(",
"username_or_email",
")",
"membership",
"=",
"CohortMembership",
"(",
"course_user_group",
"=",
"cohort",
",",
"user",
"=",
"user",
")"... | look up the given user . | train | false |
15,132 | def json_synonym(name):
def getter(self):
return json.loads(getattr(self, name), decode_datetime=True)
def setter(self, entry):
setattr(self, name, unicode(json.dumps(entry, encode_datetime=True)))
return synonym(name, descriptor=property(getter, setter))
| [
"def",
"json_synonym",
"(",
"name",
")",
":",
"def",
"getter",
"(",
"self",
")",
":",
"return",
"json",
".",
"loads",
"(",
"getattr",
"(",
"self",
",",
"name",
")",
",",
"decode_datetime",
"=",
"True",
")",
"def",
"setter",
"(",
"self",
",",
"entry",... | use json to serialize python objects for db storage . | train | false |
15,133 | def setup_switch(device_id, name, insteonhub, hass, add_devices_callback):
if (device_id in _CONFIGURING):
request_id = _CONFIGURING.pop(device_id)
configurator = get_component('configurator')
configurator.request_done(request_id)
_LOGGER.info('Device configuration done!')
conf_switch = config_from_file(hass.config.path(INSTEON_LOCAL_SWITCH_CONF))
if (device_id not in conf_switch):
conf_switch[device_id] = name
if (not config_from_file(hass.config.path(INSTEON_LOCAL_SWITCH_CONF), conf_switch)):
_LOGGER.error('Failed to save configuration file')
device = insteonhub.switch(device_id)
add_devices_callback([InsteonLocalSwitchDevice(device, name)])
| [
"def",
"setup_switch",
"(",
"device_id",
",",
"name",
",",
"insteonhub",
",",
"hass",
",",
"add_devices_callback",
")",
":",
"if",
"(",
"device_id",
"in",
"_CONFIGURING",
")",
":",
"request_id",
"=",
"_CONFIGURING",
".",
"pop",
"(",
"device_id",
")",
"config... | set up the switch . | train | false |
15,134 | def verify_tunnel_range(tunnel_range, tunnel_type):
mappings = {p_const.TYPE_GRE: is_valid_gre_id, p_const.TYPE_VXLAN: is_valid_vxlan_vni, p_const.TYPE_GENEVE: is_valid_geneve_vni}
if (tunnel_type in mappings):
for ident in tunnel_range:
if (not mappings[tunnel_type](ident)):
raise exceptions.NetworkTunnelRangeError(tunnel_range=tunnel_range, error=(_('%(id)s is not a valid %(type)s identifier') % {'id': ident, 'type': tunnel_type}))
if (tunnel_range[1] < tunnel_range[0]):
raise exceptions.NetworkTunnelRangeError(tunnel_range=tunnel_range, error=_('End of tunnel range is less than start of tunnel range'))
| [
"def",
"verify_tunnel_range",
"(",
"tunnel_range",
",",
"tunnel_type",
")",
":",
"mappings",
"=",
"{",
"p_const",
".",
"TYPE_GRE",
":",
"is_valid_gre_id",
",",
"p_const",
".",
"TYPE_VXLAN",
":",
"is_valid_vxlan_vni",
",",
"p_const",
".",
"TYPE_GENEVE",
":",
"is_... | raise an exception for invalid tunnel range or malformed range . | train | false |
15,135 | def formatted_response(response, fields, labels, iterable=None):
output_format = validated_parameter(request.args, 'format', values=['json', 'json_lines', 'csv'], default='json')
header_type = validated_parameter(request.args, 'header', values=['names', 'labels', 'none'], default='labels')
if (header_type == 'names'):
header = fields
elif (header_type == 'labels'):
header = labels
else:
header = None
iterable = (iterable or response)
if (output_format == 'json'):
return jsonify(response)
elif (output_format == 'json_lines'):
return Response(JSONLinesGenerator(iterable), mimetype='application/x-json-lines')
elif (output_format == 'csv'):
generator = csv_generator(iterable, fields, include_header=bool(header), header=header)
headers = {'Content-Disposition': 'attachment; filename="facts.csv"'}
return Response(generator, mimetype='text/csv', headers=headers)
| [
"def",
"formatted_response",
"(",
"response",
",",
"fields",
",",
"labels",
",",
"iterable",
"=",
"None",
")",
":",
"output_format",
"=",
"validated_parameter",
"(",
"request",
".",
"args",
",",
"'format'",
",",
"values",
"=",
"[",
"'json'",
",",
"'json_line... | wraps request which returns response that can be formatted . | train | false |
15,136 | def _Intersect(handler_list):
if (not handler_list):
return set()
handlers = set([handler_list[0]])
for input_handler in handler_list[1:]:
new_handlers = set()
for g in handlers:
new_handlers |= _IntersectTwoHandlers(input_handler, g)
handlers = new_handlers
return list(handlers)
| [
"def",
"_Intersect",
"(",
"handler_list",
")",
":",
"if",
"(",
"not",
"handler_list",
")",
":",
"return",
"set",
"(",
")",
"handlers",
"=",
"set",
"(",
"[",
"handler_list",
"[",
"0",
"]",
"]",
")",
"for",
"input_handler",
"in",
"handler_list",
"[",
"1"... | returns an unordered list of all possible intersections of handlers . | train | false |
15,139 | def test_Gpujoin_inplace():
s = T.lscalar()
data = numpy.array([3, 4, 5], dtype=theano.config.floatX)
x = gpuarray_shared_constructor(data, borrow=True)
z = T.zeros((s,))
join = GpuJoin(view=0)
c = join(0, x, z)
f = theano.function([s], theano.Out(c, borrow=True))
assert (x.get_value(borrow=True, return_internal_type=True) is f(0))
assert numpy.allclose(f(0), [3, 4, 5])
| [
"def",
"test_Gpujoin_inplace",
"(",
")",
":",
"s",
"=",
"T",
".",
"lscalar",
"(",
")",
"data",
"=",
"numpy",
".",
"array",
"(",
"[",
"3",
",",
"4",
",",
"5",
"]",
",",
"dtype",
"=",
"theano",
".",
"config",
".",
"floatX",
")",
"x",
"=",
"gpuarr... | test gpujoin to work inplace . | train | false |
15,140 | def restarted(manager, containers, count, name):
containers.refresh()
for container in manager.get_differing_containers():
manager.stop_containers([container])
manager.remove_containers([container])
containers.refresh()
manager.restart_containers(containers.running)
started(manager, containers, count, name)
| [
"def",
"restarted",
"(",
"manager",
",",
"containers",
",",
"count",
",",
"name",
")",
":",
"containers",
".",
"refresh",
"(",
")",
"for",
"container",
"in",
"manager",
".",
"get_differing_containers",
"(",
")",
":",
"manager",
".",
"stop_containers",
"(",
... | require a service to be restarted . | train | false |
15,142 | def ParseJSONResponse(response):
content_type = response.headers.get('Content-Type', '')
if (not any((content_type.startswith(x) for x in _CONTENT_TYPES))):
raise web.HTTPError(response.code, ('%r' % response.headers))
try:
json_dict = json.loads(response.body)
except:
if (response.code == 200):
raise
json_dict = {'error': response.body}
if (response.code != 200):
error = 'unknown'
if (isinstance(json_dict, dict) and json_dict.get('error')):
error = json_dict.get('error')
raise web.HTTPError(response.code, ('%s' % error))
return json_dict
| [
"def",
"ParseJSONResponse",
"(",
"response",
")",
":",
"content_type",
"=",
"response",
".",
"headers",
".",
"get",
"(",
"'Content-Type'",
",",
"''",
")",
"if",
"(",
"not",
"any",
"(",
"(",
"content_type",
".",
"startswith",
"(",
"x",
")",
"for",
"x",
... | parse the json-encoded contents of the response body and return the python data object . | train | false |
15,143 | def hough_ellipse(img, threshold=4, accuracy=1, min_size=4, max_size=None):
return _hough_ellipse(img, threshold, accuracy, min_size, max_size)
| [
"def",
"hough_ellipse",
"(",
"img",
",",
"threshold",
"=",
"4",
",",
"accuracy",
"=",
"1",
",",
"min_size",
"=",
"4",
",",
"max_size",
"=",
"None",
")",
":",
"return",
"_hough_ellipse",
"(",
"img",
",",
"threshold",
",",
"accuracy",
",",
"min_size",
",... | perform an elliptical hough transform . | train | false |
15,144 | @pytest.mark.cmd
@pytest.mark.parametrize('command,app', [(command, app) for (command, app) in get_commands().iteritems() if (app.startswith('pootle_') or (app in CORE_APPS_WITH_COMMANDS))])
def test_initdb_help(capfd, command, app):
print ('Command: %s, App: %s' % (command, app))
with pytest.raises(SystemExit):
call_command(command, '--help')
(out, err) = capfd.readouterr()
assert ('--help' in out)
| [
"@",
"pytest",
".",
"mark",
".",
"cmd",
"@",
"pytest",
".",
"mark",
".",
"parametrize",
"(",
"'command,app'",
",",
"[",
"(",
"command",
",",
"app",
")",
"for",
"(",
"command",
",",
"app",
")",
"in",
"get_commands",
"(",
")",
".",
"iteritems",
"(",
... | catch any simple command issues . | train | false |
15,146 | def is_email_valid(email_address):
return (invalid_email_reason(email_address, '') is None)
| [
"def",
"is_email_valid",
"(",
"email_address",
")",
":",
"return",
"(",
"invalid_email_reason",
"(",
"email_address",
",",
"''",
")",
"is",
"None",
")"
] | determine if email is invalid . | train | false |
15,148 | def _username():
if pwd:
username = pwd.getpwuid(os.getuid()).pw_name
else:
username = getpass.getuser()
return username
| [
"def",
"_username",
"(",
")",
":",
"if",
"pwd",
":",
"username",
"=",
"pwd",
".",
"getpwuid",
"(",
"os",
".",
"getuid",
"(",
")",
")",
".",
"pw_name",
"else",
":",
"username",
"=",
"getpass",
".",
"getuser",
"(",
")",
"return",
"username"
] | grain for the minion username . | train | true |
15,150 | def weights_bartlett(nlags):
return (1 - (np.arange((nlags + 1)) / (nlags + 1.0)))
| [
"def",
"weights_bartlett",
"(",
"nlags",
")",
":",
"return",
"(",
"1",
"-",
"(",
"np",
".",
"arange",
"(",
"(",
"nlags",
"+",
"1",
")",
")",
"/",
"(",
"nlags",
"+",
"1.0",
")",
")",
")"
] | bartlett weights for hac this will be moved to another module parameters nlags : int highest lag in the kernel window . | train | false |
15,151 | def init_flowgram_file(filename=None, n=0, l=400, prefix='/tmp/'):
if (filename is None):
(fd, filename) = mkstemp(dir=prefix, suffix='.dat')
close(fd)
fh = open(filename, 'w')
fh.write(('%d %d\n' % (n, l)))
return (fh, filename)
| [
"def",
"init_flowgram_file",
"(",
"filename",
"=",
"None",
",",
"n",
"=",
"0",
",",
"l",
"=",
"400",
",",
"prefix",
"=",
"'/tmp/'",
")",
":",
"if",
"(",
"filename",
"is",
"None",
")",
":",
"(",
"fd",
",",
"filename",
")",
"=",
"mkstemp",
"(",
"di... | opens a file in plain flowgram format and writes header information . | train | false |
15,153 | def adjust_timestamp(ts, offset, here=utcoffset):
return (ts - ((offset - here()) * 3600))
| [
"def",
"adjust_timestamp",
"(",
"ts",
",",
"offset",
",",
"here",
"=",
"utcoffset",
")",
":",
"return",
"(",
"ts",
"-",
"(",
"(",
"offset",
"-",
"here",
"(",
")",
")",
"*",
"3600",
")",
")"
] | adjust timestamp based on provided utcoffset . | train | false |
15,154 | def do_organization_info(ava):
if (ava is None):
return None
org = md.Organization()
for (dkey, (ckey, klass)) in ORG_ATTR_TRANSL.items():
if (ckey not in ava):
continue
if isinstance(ava[ckey], basestring):
setattr(org, dkey, [_localized_name(ava[ckey], klass)])
elif isinstance(ava[ckey], list):
setattr(org, dkey, [_localized_name(n, klass) for n in ava[ckey]])
else:
setattr(org, dkey, [_localized_name(ava[ckey], klass)])
return org
| [
"def",
"do_organization_info",
"(",
"ava",
")",
":",
"if",
"(",
"ava",
"is",
"None",
")",
":",
"return",
"None",
"org",
"=",
"md",
".",
"Organization",
"(",
")",
"for",
"(",
"dkey",
",",
"(",
"ckey",
",",
"klass",
")",
")",
"in",
"ORG_ATTR_TRANSL",
... | description of an organization in the configuration is a dictionary of keys and values . | train | true |
15,156 | def compare_languge(language, lang_list):
found = False
for l in lang_list:
if (language == l.lower()):
found = True
break
return found
| [
"def",
"compare_languge",
"(",
"language",
",",
"lang_list",
")",
":",
"found",
"=",
"False",
"for",
"l",
"in",
"lang_list",
":",
"if",
"(",
"language",
"==",
"l",
".",
"lower",
"(",
")",
")",
":",
"found",
"=",
"True",
"break",
"return",
"found"
] | check if language is found . | train | false |
15,157 | def rstrips(text, remove):
return _strips('r', text, remove)
| [
"def",
"rstrips",
"(",
"text",
",",
"remove",
")",
":",
"return",
"_strips",
"(",
"'r'",
",",
"text",
",",
"remove",
")"
] | removes the string remove from the right of text . | train | false |
15,158 | def send_nscript(title, msg, gtype, force=False, test=None):
if test:
script = test.get('nscript_script')
parameters = test.get('nscript_parameters')
else:
script = sabnzbd.cfg.nscript_script()
parameters = sabnzbd.cfg.nscript_parameters()
if (not script):
return T('Cannot send, missing required data')
title = (u'SABnzbd: ' + Tx(NOTIFICATION.get(gtype, 'other')))
if (force or check_classes(gtype, 'nscript')):
script_path = make_script_path(script)
if script_path:
(output, ret) = external_script(script_path, gtype, title, msg, parameters)
if ret:
logging.error((T('Script returned exit code %s and output "%s"') % (ret, output)))
return (T('Script returned exit code %s and output "%s"') % (ret, output))
else:
logging.info(('Successfully executed notification script ' + script_path))
else:
return (T('Notification script "%s" does not exist') % script_path)
return ''
| [
"def",
"send_nscript",
"(",
"title",
",",
"msg",
",",
"gtype",
",",
"force",
"=",
"False",
",",
"test",
"=",
"None",
")",
":",
"if",
"test",
":",
"script",
"=",
"test",
".",
"get",
"(",
"'nscript_script'",
")",
"parameters",
"=",
"test",
".",
"get",
... | run users notification script . | train | false |
15,159 | def lint_repeats(tool_xml, lint_ctx):
repeats = tool_xml.findall('./inputs//repeat')
for repeat in repeats:
if ('name' not in repeat.attrib):
lint_ctx.error('Repeat does not specify name attribute.')
if ('title' not in repeat.attrib):
lint_ctx.error('Repeat does not specify title attribute.')
| [
"def",
"lint_repeats",
"(",
"tool_xml",
",",
"lint_ctx",
")",
":",
"repeats",
"=",
"tool_xml",
".",
"findall",
"(",
"'./inputs//repeat'",
")",
"for",
"repeat",
"in",
"repeats",
":",
"if",
"(",
"'name'",
"not",
"in",
"repeat",
".",
"attrib",
")",
":",
"li... | lint repeat blocks in tool inputs . | train | false |
15,160 | def _iscommand(cmd):
if _isexecutable(cmd):
return True
path = os.environ.get('PATH')
if (not path):
return False
for d in path.split(os.pathsep):
exe = os.path.join(d, cmd)
if _isexecutable(exe):
return True
return False
| [
"def",
"_iscommand",
"(",
"cmd",
")",
":",
"if",
"_isexecutable",
"(",
"cmd",
")",
":",
"return",
"True",
"path",
"=",
"os",
".",
"environ",
".",
"get",
"(",
"'PATH'",
")",
"if",
"(",
"not",
"path",
")",
":",
"return",
"False",
"for",
"d",
"in",
... | return true if cmd is executable or can be found on the executable search path . | train | false |
15,161 | def test_cache_deactivated_remove_data(config_stub, tmpdir):
config_stub.data = {'storage': {'cache-size': 1024}, 'general': {'private-browsing': True}}
disk_cache = cache.DiskCache(str(tmpdir))
url = QUrl('http://www.example.com/')
assert (not disk_cache.remove(url))
| [
"def",
"test_cache_deactivated_remove_data",
"(",
"config_stub",
",",
"tmpdir",
")",
":",
"config_stub",
".",
"data",
"=",
"{",
"'storage'",
":",
"{",
"'cache-size'",
":",
"1024",
"}",
",",
"'general'",
":",
"{",
"'private-browsing'",
":",
"True",
"}",
"}",
... | test removing some data from a deactivated cache . | train | false |
15,163 | def describe_template_sets():
import inspect
import sys
templatesets = inspect.getmembers(sys.modules[__name__], inspect.isfunction)
for (name, obj) in templatesets:
if (name == 'describe_template_sets'):
continue
print(name, obj.__doc__, '\n')
| [
"def",
"describe_template_sets",
"(",
")",
":",
"import",
"inspect",
"import",
"sys",
"templatesets",
"=",
"inspect",
".",
"getmembers",
"(",
"sys",
".",
"modules",
"[",
"__name__",
"]",
",",
"inspect",
".",
"isfunction",
")",
"for",
"(",
"name",
",",
"obj... | print the available template sets in this demo . | train | false |
15,164 | def _load_all_namespaces(resolver):
url_patterns = getattr(resolver, 'url_patterns', [])
namespaces = [url.namespace for url in url_patterns if (getattr(url, 'namespace', None) is not None)]
for pattern in url_patterns:
namespaces.extend(_load_all_namespaces(pattern))
return namespaces
| [
"def",
"_load_all_namespaces",
"(",
"resolver",
")",
":",
"url_patterns",
"=",
"getattr",
"(",
"resolver",
",",
"'url_patterns'",
",",
"[",
"]",
")",
"namespaces",
"=",
"[",
"url",
".",
"namespace",
"for",
"url",
"in",
"url_patterns",
"if",
"(",
"getattr",
... | recursively load all namespaces from url patterns . | train | false |
15,165 | def get_provider_driver_class(driver, namespace=SERVICE_PROVIDERS):
try:
driver_manager = stevedore.driver.DriverManager(namespace, driver).driver
except ImportError:
return driver
except RuntimeError:
return driver
new_driver = ('%s.%s' % (driver_manager.__module__, driver_manager.__name__))
LOG.warning(_LW('The configured driver %(driver)s has been moved, automatically using %(new_driver)s instead. Please update your config files, as this automatic fixup will be removed in a future release.'), {'driver': driver, 'new_driver': new_driver})
return new_driver
| [
"def",
"get_provider_driver_class",
"(",
"driver",
",",
"namespace",
"=",
"SERVICE_PROVIDERS",
")",
":",
"try",
":",
"driver_manager",
"=",
"stevedore",
".",
"driver",
".",
"DriverManager",
"(",
"namespace",
",",
"driver",
")",
".",
"driver",
"except",
"ImportEr... | return path to provider driver class in order to keep backward compatibility with configs < kilo . | train | false |
15,166 | def list_refs(refnames=None, repo_dir=None, limit_to_heads=False, limit_to_tags=False):
argv = ['git', 'show-ref']
if limit_to_heads:
argv.append('--heads')
if limit_to_tags:
argv.append('--tags')
argv.append('--')
if refnames:
argv += refnames
p = subprocess.Popen(argv, preexec_fn=_gitenv(repo_dir), stdout=subprocess.PIPE)
out = p.stdout.read().strip()
rv = p.wait()
if rv:
assert (not out)
if out:
for d in out.split('\n'):
(sha, name) = d.split(' ', 1)
(yield (name, sha.decode('hex')))
| [
"def",
"list_refs",
"(",
"refnames",
"=",
"None",
",",
"repo_dir",
"=",
"None",
",",
"limit_to_heads",
"=",
"False",
",",
"limit_to_tags",
"=",
"False",
")",
":",
"argv",
"=",
"[",
"'git'",
",",
"'show-ref'",
"]",
"if",
"limit_to_heads",
":",
"argv",
"."... | yield tuples for all repository refs unless refnames are specified . | train | false |
15,167 | def _ts_kde(ax, x, data, color, **kwargs):
kde_data = []
(y_min, y_max) = (data.min(), data.max())
y_vals = np.linspace(y_min, y_max, 100)
upsampler = interpolate.interp1d(x, data)
data_upsample = upsampler(np.linspace(x.min(), x.max(), 100))
for pt_data in data_upsample.T:
pt_kde = stats.kde.gaussian_kde(pt_data)
kde_data.append(pt_kde(y_vals))
kde_data = np.transpose(kde_data)
rgb = mpl.colors.ColorConverter().to_rgb(color)
img = np.zeros((kde_data.shape[0], kde_data.shape[1], 4))
img[:, :, :3] = rgb
kde_data /= kde_data.max(axis=0)
kde_data[(kde_data > 1)] = 1
img[:, :, 3] = kde_data
ax.imshow(img, interpolation='spline16', zorder=2, extent=(x.min(), x.max(), y_min, y_max), aspect='auto', origin='lower')
| [
"def",
"_ts_kde",
"(",
"ax",
",",
"x",
",",
"data",
",",
"color",
",",
"**",
"kwargs",
")",
":",
"kde_data",
"=",
"[",
"]",
"(",
"y_min",
",",
"y_max",
")",
"=",
"(",
"data",
".",
"min",
"(",
")",
",",
"data",
".",
"max",
"(",
")",
")",
"y_... | upsample over time and plot a kde of the bootstrap distribution . | train | false |
15,170 | def status_battery():
data = status()
if ('TONBATT' in data):
return (not (data['TONBATT'] == '0 Seconds'))
return {'Error': 'Battery status not available.'}
| [
"def",
"status_battery",
"(",
")",
":",
"data",
"=",
"status",
"(",
")",
"if",
"(",
"'TONBATT'",
"in",
"data",
")",
":",
"return",
"(",
"not",
"(",
"data",
"[",
"'TONBATT'",
"]",
"==",
"'0 Seconds'",
")",
")",
"return",
"{",
"'Error'",
":",
"'Battery... | return true if running on battery power cli example: . | train | false |
15,171 | def set_gamedir(path):
global GAMEDIR
Ndepth = 10
settings_path = os.path.join('server', 'conf', 'settings.py')
for i in range(Ndepth):
gpath = os.getcwd()
if ('server' in os.listdir(gpath)):
if os.path.isfile(settings_path):
GAMEDIR = gpath
return
os.chdir(os.pardir)
print(ERROR_NO_GAMEDIR)
sys.exit()
| [
"def",
"set_gamedir",
"(",
"path",
")",
":",
"global",
"GAMEDIR",
"Ndepth",
"=",
"10",
"settings_path",
"=",
"os",
".",
"path",
".",
"join",
"(",
"'server'",
",",
"'conf'",
",",
"'settings.py'",
")",
"for",
"i",
"in",
"range",
"(",
"Ndepth",
")",
":",
... | set gamedir based on path . | train | false |
15,172 | def SetQuickFixList(quickfix_list, focus=False, autoclose=False):
vim.eval(u'setqflist( {0} )'.format(json.dumps(quickfix_list)))
OpenQuickFixList(focus, autoclose)
| [
"def",
"SetQuickFixList",
"(",
"quickfix_list",
",",
"focus",
"=",
"False",
",",
"autoclose",
"=",
"False",
")",
":",
"vim",
".",
"eval",
"(",
"u'setqflist( {0} )'",
".",
"format",
"(",
"json",
".",
"dumps",
"(",
"quickfix_list",
")",
")",
")",
"OpenQuickF... | populate the quickfix list and open it . | train | false |
15,174 | def downsample(data, n, axis=0, xvals='subsample'):
ma = None
if (hasattr(data, 'implements') and data.implements('MetaArray')):
ma = data
data = data.view(np.ndarray)
if hasattr(axis, '__len__'):
if (not hasattr(n, '__len__')):
n = ([n] * len(axis))
for i in range(len(axis)):
data = downsample(data, n[i], axis[i])
return data
if (n <= 1):
return data
nPts = int((data.shape[axis] / n))
s = list(data.shape)
s[axis] = nPts
s.insert((axis + 1), n)
sl = ([slice(None)] * data.ndim)
sl[axis] = slice(0, (nPts * n))
d1 = data[tuple(sl)]
d1.shape = tuple(s)
d2 = d1.mean((axis + 1))
if (ma is None):
return d2
else:
info = ma.infoCopy()
if ('values' in info[axis]):
if (xvals == 'subsample'):
info[axis]['values'] = info[axis]['values'][::n][:nPts]
elif (xvals == 'downsample'):
info[axis]['values'] = downsample(info[axis]['values'], n)
return MetaArray(d2, info=info)
| [
"def",
"downsample",
"(",
"data",
",",
"n",
",",
"axis",
"=",
"0",
",",
"xvals",
"=",
"'subsample'",
")",
":",
"ma",
"=",
"None",
"if",
"(",
"hasattr",
"(",
"data",
",",
"'implements'",
")",
"and",
"data",
".",
"implements",
"(",
"'MetaArray'",
")",
... | downsample by averaging points together across axis . | train | false |
15,175 | def config_edit_using_option_strings(config_filepath, desired_option_strings, section, edit=False):
desired_options = [parse_option_string(section, desired_option_string, raise_on_error=True) for desired_option_string in desired_option_strings]
config_edit(config_filepath, desired_options, edit=edit)
| [
"def",
"config_edit_using_option_strings",
"(",
"config_filepath",
",",
"desired_option_strings",
",",
"section",
",",
"edit",
"=",
"False",
")",
":",
"desired_options",
"=",
"[",
"parse_option_string",
"(",
"section",
",",
"desired_option_string",
",",
"raise_on_error"... | writes the desired_option_strings to the config file . | train | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.